// Copyright 2011 National Instruments
// License: NATIONAL INSTRUMENTS SOFTWARE LICENSE AGREEMENT
//   Refer to "MHDDK License Agreement.pdf" in the root of this distribution.

// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// This file is autogenerated!!!
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!

#ifndef ___tDO_ipp___
#define ___tDO_ipp___

#ifndef ___tDO_h___
#include "tDO.h"
#endif

#ifndef ___nNIMXRegistermap_tStatus2Ptr_ipp___
#define ___nNIMXRegistermap_tStatus2Ptr_ipp___

typedef nMDBG::tStatus2 nNIMXRegisterMap120_tStatus2;


namespace nNIMXRegisterMap120 {
namespace {

typedef nNIMXRegisterMap120_tStatus2 tStatus2;

inline void setStatus(tStatus2* s, tStatus newStatus)
{
   if (s) s->setCode(newStatus);
}

inline tStatus* toPALStatusPtr(tStatus2* s)
{
   return s ? s->operator tStatus*() : ((tStatus*)NULL);
}

inline tBoolean statusIsFatal(tStatus2* s)
{
   return s && s->isFatal();
}

} // unnamed namespace
} // namespace nNIMXRegisterMap120

#endif // ___nNIMXRegistermap_tStatus2Ptr_ipp___


inline void tDO::tReg8IODirect32::write(
   tBusSpaceReference addrSpace,
   u32 offset,
   u8 value,
   nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   addrSpace.write8(offset, value);
}
inline u8 tDO::tReg8IODirect32::read(
   tBusSpaceReference addrSpace,
   u32 offset,
   nMDBG::tStatus2* s)
{
   u8 value = (u8)~0;
   if (s && s->isFatal()) return value;
   value = (u8)addrSpace.read8(offset);
   return value;
}

inline void tDO::tReg32IODirect32::write(
   tBusSpaceReference addrSpace,
   u32 offset,
   u32 value,
   nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   addrSpace.write32(offset, value);
}

inline u32 tDO::tReg32IODirect32::read(
   tBusSpaceReference addrSpace,
   u32 offset,
   nMDBG::tStatus2* s)
{
   u32 value = (u32)~0;
   if (s && s->isFatal()) return value;
   value = addrSpace.read32(offset);
   return value;
}

inline tBusSpaceReference tDO::getBusSpaceReference(void) const
{
   return _addrSpace;
}

inline void tDO::setAddressOffset(u32 value, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _addressOffset = value;
}
inline u32 tDO::getAddressOffset(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return 0UL;
   return _addressOffset;
}
inline tBoolean tDO::isDirty(tId id, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return kFalse;
   u32 regId = id&0x01FFFFFF;
   if (regId > kMaxRegisterId) {
      nNIMXRegisterMap120::setStatus(s, kStatusBadSelector);
      return kFalse;
   }

   return _dirtyVector[regId];
}

inline void tDO::markDirty(tId id, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   u32 regId = id&0x01FFFFFF;

   if (regId > kMaxRegisterId) {
      nNIMXRegisterMap120::setStatus(s, kStatusBadSelector);
      return;
   }

   _dirtyVector[regId] = 1;
}

inline void tDO::markClean(tId id, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   u32 regId = id&0x01FFFFFF;

   if (regId > kMaxRegisterId) {
      nNIMXRegisterMap120::setStatus(s, kStatusBadSelector);
      return;
   }

   _dirtyVector[regId] = 0;
}

inline void tDO::markDirty(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   unsigned int i;
   for (i = 0; i < sizeof(_dirtyVector)/sizeof(_dirtyVector[0]); i++) {
      _dirtyVector[i] = 1;
   }
}

inline void tDO::markClean(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   for (unsigned int i = 0; i < sizeof(_dirtyVector)/sizeof(_dirtyVector[0]); i++) {
      _dirtyVector[i] = 0;
   }
}

inline tDO::tDO_FIFO_St_Register::tDO_FIFO_St_Register()
{
   _softCopy = u32(0x0);
}

inline tDO::tDO_FIFO_St_Register::tRegisterMap* tDO::tDO_FIFO_St_Register::registerMap(void)
{
   return _regMap;
}

inline void tDO::tDO_FIFO_St_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tDO::tDO_FIFO_St_Register& tDO::tDO_FIFO_St_Register::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   _softCopy = fieldValue;
   return *this;
}

inline u32 tDO::tDO_FIFO_St_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tDO::tDO_FIFO_St_Register::refresh(nMDBG::tStatus2* s)
{
   _softCopy = tIOStrategy::read(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), s);
}

inline u32 tDO::tDO_FIFO_St_Register::readRegister(nMDBG::tStatus2* s)
{
   refresh(s);
   return _softCopy;
}

inline tDO::tDO_FIFO_St_Register& tDO::tDO_FIFO_St_Register::setDO_FIFO_FullCount(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffff0000) | ((u32(fieldValue) << 0x0) & ~0xffff0000);
   setRegister(newValue, s);
   return *this;
}

inline u32 tDO::tDO_FIFO_St_Register::getDO_FIFO_FullCount(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xffff0000) >> 0x0);
}

inline u32 tDO::tDO_FIFO_St_Register::readDO_FIFO_FullCount(nMDBG::tStatus2* s)
{
   refresh(s);
   return getDO_FIFO_FullCount(s);
}

inline tDO::tSCXI_DIO_Enable_Register::tSCXI_DIO_Enable_Register()
{
   _softCopy = u8(0x0);
}

inline tDO::tSCXI_DIO_Enable_Register::tRegisterMap* tDO::tSCXI_DIO_Enable_Register::registerMap(void)
{
   return _regMap;
}

inline void tDO::tSCXI_DIO_Enable_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tBoolean tDO::tSCXI_DIO_Enable_Register::isDirty(nMDBG::tStatus2* s)
{
   return _regMap->isDirty((tDO::tId)kId, s);
}

inline void tDO::tSCXI_DIO_Enable_Register::markDirty(nMDBG::tStatus2* s)
{
   _regMap->markDirty((tDO::tId)kId, s);
}

inline void tDO::tSCXI_DIO_Enable_Register::markClean(nMDBG::tStatus2* s)
{
   _regMap->markClean((tDO::tId)kId, s);
}

inline tDO::tSCXI_DIO_Enable_Register& tDO::tSCXI_DIO_Enable_Register::setRegister(u8 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   if (_softCopy != fieldValue) {
      _softCopy = fieldValue;
      markDirty(s);
   }
   return *this;
}

inline u8 tDO::tSCXI_DIO_Enable_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tDO::tSCXI_DIO_Enable_Register::flush(nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   if (force || isDirty(s)) {
      tIOStrategy::write(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), _softCopy, s);
      _softCopy &= u8(0xff);
      _softCopy |= u8(0x0);
      markClean(s);
   }
}

inline void tDO::tSCXI_DIO_Enable_Register::writeRegister(u8 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   force = force || (_softCopy != fieldValue);
   _softCopy = fieldValue;
   flush(s, force);
}

inline u8 tDO::tSCXI_DIO_Enable_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tDO::tSCXI_DIO_Enable_Register& tDO::tSCXI_DIO_Enable_Register::setSCXI_DIO_MOSI_Enable(u8 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u8 newValue;   newValue = (_softCopy & 0xfe) | ((u8(fieldValue) << 0x0) & ~0xfe);
   setRegister(newValue, s);
   return *this;
}

inline u8 tDO::tSCXI_DIO_Enable_Register::getSCXI_DIO_MOSI_Enable(nMDBG::tStatus2*) const
{
   return u8((_softCopy & ~0xfe) >> 0x0);
}

inline void tDO::tSCXI_DIO_Enable_Register::writeSCXI_DIO_MOSI_Enable(u8 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setSCXI_DIO_MOSI_Enable(fieldValue, s);
   flush(s, force);
}
inline u8 tDO::tSCXI_DIO_Enable_Register::readSCXI_DIO_MOSI_Enable(nMDBG::tStatus2* s)
{
   return getSCXI_DIO_MOSI_Enable(s);
}

inline tDO::tSCXI_DIO_Enable_Register& tDO::tSCXI_DIO_Enable_Register::setSCXI_DIO_D_A_Enable(u8 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u8 newValue;   newValue = (_softCopy & 0xfd) | ((u8(fieldValue) << 0x1) & ~0xfd);
   setRegister(newValue, s);
   return *this;
}

inline u8 tDO::tSCXI_DIO_Enable_Register::getSCXI_DIO_D_A_Enable(nMDBG::tStatus2*) const
{
   return u8((_softCopy & ~0xfd) >> 0x1);
}

inline void tDO::tSCXI_DIO_Enable_Register::writeSCXI_DIO_D_A_Enable(u8 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setSCXI_DIO_D_A_Enable(fieldValue, s);
   flush(s, force);
}
inline u8 tDO::tSCXI_DIO_Enable_Register::readSCXI_DIO_D_A_Enable(nMDBG::tStatus2* s)
{
   return getSCXI_DIO_D_A_Enable(s);
}

inline tDO::tSCXI_DIO_Enable_Register& tDO::tSCXI_DIO_Enable_Register::setSCXI_DIO_Intr_Enable(u8 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u8 newValue;   newValue = (_softCopy & 0xfb) | ((u8(fieldValue) << 0x2) & ~0xfb);
   setRegister(newValue, s);
   return *this;
}

inline u8 tDO::tSCXI_DIO_Enable_Register::getSCXI_DIO_Intr_Enable(nMDBG::tStatus2*) const
{
   return u8((_softCopy & ~0xfb) >> 0x2);
}

inline void tDO::tSCXI_DIO_Enable_Register::writeSCXI_DIO_Intr_Enable(u8 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setSCXI_DIO_Intr_Enable(fieldValue, s);
   flush(s, force);
}
inline u8 tDO::tSCXI_DIO_Enable_Register::readSCXI_DIO_Intr_Enable(nMDBG::tStatus2* s)
{
   return getSCXI_DIO_Intr_Enable(s);
}

inline tDO::tStatic_Digital_Output_Register::tStatic_Digital_Output_Register()
{
   _softCopy = u32(0x0);
}

inline tDO::tStatic_Digital_Output_Register::tRegisterMap* tDO::tStatic_Digital_Output_Register::registerMap(void)
{
   return _regMap;
}

inline void tDO::tStatic_Digital_Output_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tBoolean tDO::tStatic_Digital_Output_Register::isDirty(nMDBG::tStatus2* s)
{
   return _regMap->isDirty((tDO::tId)kId, s);
}

inline void tDO::tStatic_Digital_Output_Register::markDirty(nMDBG::tStatus2* s)
{
   _regMap->markDirty((tDO::tId)kId, s);
}

inline void tDO::tStatic_Digital_Output_Register::markClean(nMDBG::tStatus2* s)
{
   _regMap->markClean((tDO::tId)kId, s);
}

inline tDO::tStatic_Digital_Output_Register& tDO::tStatic_Digital_Output_Register::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   if (_softCopy != fieldValue) {
      _softCopy = fieldValue;
      markDirty(s);
   }
   return *this;
}

inline u32 tDO::tStatic_Digital_Output_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tDO::tStatic_Digital_Output_Register::flush(nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   if (force || isDirty(s)) {
      tIOStrategy::write(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), _softCopy, s);
      _softCopy &= u32(0xffffffff);
      _softCopy |= u32(0x0);
      markClean(s);
   }
}

inline void tDO::tStatic_Digital_Output_Register::writeRegister(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   force = force || (_softCopy != fieldValue);
   _softCopy = fieldValue;
   flush(s, force);
}

inline u32 tDO::tStatic_Digital_Output_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tDO::tStatic_Digital_Output_Register& tDO::tStatic_Digital_Output_Register::setDO_StaticValue(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0x0) | ((u32(fieldValue) << 0x0) & ~0x0);
   setRegister(newValue, s);
   return *this;
}

inline u32 tDO::tStatic_Digital_Output_Register::getDO_StaticValue(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline void tDO::tStatic_Digital_Output_Register::writeDO_StaticValue(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_StaticValue(fieldValue, s);
   flush(s, force);
}
inline u32 tDO::tStatic_Digital_Output_Register::readDO_StaticValue(nMDBG::tStatus2* s)
{
   return getDO_StaticValue(s);
}

inline tDO::tDIO_Direction_Register::tDIO_Direction_Register()
{
   _softCopy = u32(0x0);
}

inline tDO::tDIO_Direction_Register::tRegisterMap* tDO::tDIO_Direction_Register::registerMap(void)
{
   return _regMap;
}

inline void tDO::tDIO_Direction_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tBoolean tDO::tDIO_Direction_Register::isDirty(nMDBG::tStatus2* s)
{
   return _regMap->isDirty((tDO::tId)kId, s);
}

inline void tDO::tDIO_Direction_Register::markDirty(nMDBG::tStatus2* s)
{
   _regMap->markDirty((tDO::tId)kId, s);
}

inline void tDO::tDIO_Direction_Register::markClean(nMDBG::tStatus2* s)
{
   _regMap->markClean((tDO::tId)kId, s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   if (_softCopy != fieldValue) {
      _softCopy = fieldValue;
      markDirty(s);
   }
   return *this;
}

inline u32 tDO::tDIO_Direction_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tDO::tDIO_Direction_Register::flush(nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   if (force || isDirty(s)) {
      tIOStrategy::write(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), _softCopy, s);
      _softCopy &= u32(0xffffffff);
      _softCopy |= u32(0x0);
      markClean(s);
   }
}

inline void tDO::tDIO_Direction_Register::writeRegister(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   force = force || (_softCopy != fieldValue);
   _softCopy = fieldValue;
   flush(s, force);
}

inline u32 tDO::tDIO_Direction_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin0(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffffe) | ((u32(fieldValue) << 0x0) & ~0xfffffffe);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin0(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xfffffffe) >> 0x0);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin0(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin0(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin0(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin0(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin1(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffffd) | ((u32(fieldValue) << 0x1) & ~0xfffffffd);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin1(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xfffffffd) >> 0x1);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin1(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin1(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin1(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin1(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin2(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffffb) | ((u32(fieldValue) << 0x2) & ~0xfffffffb);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin2(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xfffffffb) >> 0x2);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin2(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin2(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin2(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin2(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin3(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffff7) | ((u32(fieldValue) << 0x3) & ~0xfffffff7);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin3(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xfffffff7) >> 0x3);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin3(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin3(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin3(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin3(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin4(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffffef) | ((u32(fieldValue) << 0x4) & ~0xffffffef);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin4(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xffffffef) >> 0x4);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin4(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin4(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin4(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin4(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin5(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffffdf) | ((u32(fieldValue) << 0x5) & ~0xffffffdf);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin5(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xffffffdf) >> 0x5);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin5(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin5(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin5(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin5(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin6(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffffbf) | ((u32(fieldValue) << 0x6) & ~0xffffffbf);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin6(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xffffffbf) >> 0x6);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin6(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin6(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin6(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin6(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin7(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffff7f) | ((u32(fieldValue) << 0x7) & ~0xffffff7f);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin7(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xffffff7f) >> 0x7);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin7(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin7(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin7(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin7(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin8(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffeff) | ((u32(fieldValue) << 0x8) & ~0xfffffeff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin8(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xfffffeff) >> 0x8);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin8(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin8(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin8(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin8(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin9(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffdff) | ((u32(fieldValue) << 0x9) & ~0xfffffdff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin9(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xfffffdff) >> 0x9);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin9(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin9(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin9(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin9(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin10(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffbff) | ((u32(fieldValue) << 0xa) & ~0xfffffbff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin10(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xfffffbff) >> 0xa);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin10(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin10(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin10(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin10(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin11(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffff7ff) | ((u32(fieldValue) << 0xb) & ~0xfffff7ff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin11(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xfffff7ff) >> 0xb);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin11(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin11(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin11(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin11(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin12(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffefff) | ((u32(fieldValue) << 0xc) & ~0xffffefff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin12(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xffffefff) >> 0xc);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin12(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin12(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin12(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin12(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin13(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffdfff) | ((u32(fieldValue) << 0xd) & ~0xffffdfff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin13(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xffffdfff) >> 0xd);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin13(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin13(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin13(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin13(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin14(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffbfff) | ((u32(fieldValue) << 0xe) & ~0xffffbfff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin14(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xffffbfff) >> 0xe);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin14(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin14(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin14(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin14(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin15(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffff7fff) | ((u32(fieldValue) << 0xf) & ~0xffff7fff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin15(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xffff7fff) >> 0xf);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin15(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin15(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin15(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin15(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin16(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffeffff) | ((u32(fieldValue) << 0x10) & ~0xfffeffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin16(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xfffeffff) >> 0x10);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin16(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin16(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin16(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin16(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin17(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffdffff) | ((u32(fieldValue) << 0x11) & ~0xfffdffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin17(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xfffdffff) >> 0x11);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin17(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin17(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin17(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin17(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin18(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffbffff) | ((u32(fieldValue) << 0x12) & ~0xfffbffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin18(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xfffbffff) >> 0x12);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin18(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin18(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin18(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin18(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin19(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfff7ffff) | ((u32(fieldValue) << 0x13) & ~0xfff7ffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin19(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xfff7ffff) >> 0x13);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin19(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin19(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin19(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin19(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin20(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffefffff) | ((u32(fieldValue) << 0x14) & ~0xffefffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin20(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xffefffff) >> 0x14);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin20(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin20(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin20(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin20(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin21(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffdfffff) | ((u32(fieldValue) << 0x15) & ~0xffdfffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin21(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xffdfffff) >> 0x15);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin21(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin21(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin21(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin21(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin22(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffbfffff) | ((u32(fieldValue) << 0x16) & ~0xffbfffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin22(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xffbfffff) >> 0x16);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin22(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin22(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin22(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin22(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin23(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xff7fffff) | ((u32(fieldValue) << 0x17) & ~0xff7fffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin23(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xff7fffff) >> 0x17);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin23(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin23(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin23(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin23(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin24(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfeffffff) | ((u32(fieldValue) << 0x18) & ~0xfeffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin24(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xfeffffff) >> 0x18);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin24(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin24(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin24(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin24(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin25(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfdffffff) | ((u32(fieldValue) << 0x19) & ~0xfdffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin25(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xfdffffff) >> 0x19);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin25(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin25(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin25(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin25(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin26(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfbffffff) | ((u32(fieldValue) << 0x1a) & ~0xfbffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin26(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xfbffffff) >> 0x1a);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin26(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin26(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin26(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin26(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin27(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xf7ffffff) | ((u32(fieldValue) << 0x1b) & ~0xf7ffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin27(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xf7ffffff) >> 0x1b);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin27(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin27(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin27(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin27(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin28(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xefffffff) | ((u32(fieldValue) << 0x1c) & ~0xefffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin28(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xefffffff) >> 0x1c);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin28(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin28(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin28(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin28(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin29(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xdfffffff) | ((u32(fieldValue) << 0x1d) & ~0xdfffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin29(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xdfffffff) >> 0x1d);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin29(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin29(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin29(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin29(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin30(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xbfffffff) | ((u32(fieldValue) << 0x1e) & ~0xbfffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin30(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0xbfffffff) >> 0x1e);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin30(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin30(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin30(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin30(s);
}

inline tDO::tDIO_Direction_Register& tDO::tDIO_Direction_Register::setkDIODirection_Pin31(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0x7fffffff) | ((u32(fieldValue) << 0x1f) & ~0x7fffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::getkDIODirection_Pin31(nMDBG::tStatus2*) const
{
   return nDO::tDO_LineDir_t((_softCopy & ~0x7fffffff) >> 0x1f);
}

inline void tDO::tDIO_Direction_Register::writekDIODirection_Pin31(nDO::tDO_LineDir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setkDIODirection_Pin31(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_LineDir_t tDO::tDIO_Direction_Register::readkDIODirection_Pin31(nMDBG::tStatus2* s)
{
   return getkDIODirection_Pin31(s);
}

inline tDO::tCDO_FIFO_Data_Register::tCDO_FIFO_Data_Register()
{
}

inline tDO::tCDO_FIFO_Data_Register::tRegisterMap* tDO::tCDO_FIFO_Data_Register::registerMap(void)
{
   return _regMap;
}

inline void tDO::tCDO_FIFO_Data_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline void tDO::tCDO_FIFO_Data_Register::writeRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), fieldValue, s);
}

inline void tDO::tCDO_FIFO_Data_Register::writeCDO_FIFO_Data(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x0) & ~0x0,s);
}
inline tDO::tDO_Mask_Enable_Register::tDO_Mask_Enable_Register()
{
   _softCopy = u32(0x0);
}

inline tDO::tDO_Mask_Enable_Register::tRegisterMap* tDO::tDO_Mask_Enable_Register::registerMap(void)
{
   return _regMap;
}

inline void tDO::tDO_Mask_Enable_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tBoolean tDO::tDO_Mask_Enable_Register::isDirty(nMDBG::tStatus2* s)
{
   return _regMap->isDirty((tDO::tId)kId, s);
}

inline void tDO::tDO_Mask_Enable_Register::markDirty(nMDBG::tStatus2* s)
{
   _regMap->markDirty((tDO::tId)kId, s);
}

inline void tDO::tDO_Mask_Enable_Register::markClean(nMDBG::tStatus2* s)
{
   _regMap->markClean((tDO::tId)kId, s);
}

inline tDO::tDO_Mask_Enable_Register& tDO::tDO_Mask_Enable_Register::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   if (_softCopy != fieldValue) {
      _softCopy = fieldValue;
      markDirty(s);
   }
   return *this;
}

inline u32 tDO::tDO_Mask_Enable_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tDO::tDO_Mask_Enable_Register::flush(nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   if (force || isDirty(s)) {
      tIOStrategy::write(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), _softCopy, s);
      _softCopy &= u32(0xffffffff);
      _softCopy |= u32(0x0);
      markClean(s);
   }
}

inline void tDO::tDO_Mask_Enable_Register::writeRegister(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   force = force || (_softCopy != fieldValue);
   _softCopy = fieldValue;
   flush(s, force);
}

inline u32 tDO::tDO_Mask_Enable_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tDO::tDO_Mask_Enable_Register& tDO::tDO_Mask_Enable_Register::setCDO_Mask(nDO::tDO_TimedMask_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0x0) | ((u32(fieldValue) << 0x0) & ~0x0);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_TimedMask_t tDO::tDO_Mask_Enable_Register::getCDO_Mask(nMDBG::tStatus2*) const
{
   return nDO::tDO_TimedMask_t((_softCopy & ~0x0) >> 0x0);
}

inline void tDO::tDO_Mask_Enable_Register::writeCDO_Mask(nDO::tDO_TimedMask_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setCDO_Mask(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_TimedMask_t tDO::tDO_Mask_Enable_Register::readCDO_Mask(nMDBG::tStatus2* s)
{
   return getCDO_Mask(s);
}

inline tDO::tDO_Mode_Register::tDO_Mode_Register()
{
   _softCopy = u32(0x0);
}

inline tDO::tDO_Mode_Register::tRegisterMap* tDO::tDO_Mode_Register::registerMap(void)
{
   return _regMap;
}

inline void tDO::tDO_Mode_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tBoolean tDO::tDO_Mode_Register::isDirty(nMDBG::tStatus2* s)
{
   return _regMap->isDirty((tDO::tId)kId, s);
}

inline void tDO::tDO_Mode_Register::markDirty(nMDBG::tStatus2* s)
{
   _regMap->markDirty((tDO::tId)kId, s);
}

inline void tDO::tDO_Mode_Register::markClean(nMDBG::tStatus2* s)
{
   _regMap->markClean((tDO::tId)kId, s);
}

inline tDO::tDO_Mode_Register& tDO::tDO_Mode_Register::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   if (_softCopy != fieldValue) {
      _softCopy = fieldValue;
      markDirty(s);
   }
   return *this;
}

inline u32 tDO::tDO_Mode_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tDO::tDO_Mode_Register::flush(nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   if (force || isDirty(s)) {
      tIOStrategy::write(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), _softCopy, s);
      _softCopy &= u32(0xffffffff);
      _softCopy |= u32(0x0);
      markClean(s);
   }
}

inline void tDO::tDO_Mode_Register::writeRegister(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   force = force || (_softCopy != fieldValue);
   _softCopy = fieldValue;
   flush(s, force);
}

inline u32 tDO::tDO_Mode_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tDO::tDO_Mode_Register& tDO::tDO_Mode_Register::setDO_Data_Lane(nDO::tDO_Data_Lane_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffcfff) | ((u32(fieldValue) << 0xc) & ~0xffffcfff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_Data_Lane_t tDO::tDO_Mode_Register::getDO_Data_Lane(nMDBG::tStatus2*) const
{
   return nDO::tDO_Data_Lane_t((_softCopy & ~0xffffcfff) >> 0xc);
}

inline void tDO::tDO_Mode_Register::writeDO_Data_Lane(nDO::tDO_Data_Lane_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_Data_Lane(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_Data_Lane_t tDO::tDO_Mode_Register::readDO_Data_Lane(nMDBG::tStatus2* s)
{
   return getDO_Data_Lane(s);
}

inline tDO::tDO_Mode_Register& tDO::tDO_Mode_Register::setDO_DataWidth(nDO::tDO_DataWidth_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffff3fff) | ((u32(fieldValue) << 0xe) & ~0xffff3fff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_DataWidth_t tDO::tDO_Mode_Register::getDO_DataWidth(nMDBG::tStatus2*) const
{
   return nDO::tDO_DataWidth_t((_softCopy & ~0xffff3fff) >> 0xe);
}

inline void tDO::tDO_Mode_Register::writeDO_DataWidth(nDO::tDO_DataWidth_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_DataWidth(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_DataWidth_t tDO::tDO_Mode_Register::readDO_DataWidth(nMDBG::tStatus2* s)
{
   return getDO_DataWidth(s);
}

inline tDO::tDO_Trigger_Select_Register::tDO_Trigger_Select_Register()
{
   _softCopy = u32(0x0);
}

inline tDO::tDO_Trigger_Select_Register::tRegisterMap* tDO::tDO_Trigger_Select_Register::registerMap(void)
{
   return _regMap;
}

inline void tDO::tDO_Trigger_Select_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tBoolean tDO::tDO_Trigger_Select_Register::isDirty(nMDBG::tStatus2* s)
{
   return _regMap->isDirty((tDO::tId)kId, s);
}

inline void tDO::tDO_Trigger_Select_Register::markDirty(nMDBG::tStatus2* s)
{
   _regMap->markDirty((tDO::tId)kId, s);
}

inline void tDO::tDO_Trigger_Select_Register::markClean(nMDBG::tStatus2* s)
{
   _regMap->markClean((tDO::tId)kId, s);
}

inline tDO::tDO_Trigger_Select_Register& tDO::tDO_Trigger_Select_Register::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   if (_softCopy != fieldValue) {
      _softCopy = fieldValue;
      markDirty(s);
   }
   return *this;
}

inline u32 tDO::tDO_Trigger_Select_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tDO::tDO_Trigger_Select_Register::flush(nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   if (force || isDirty(s)) {
      tIOStrategy::write(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), _softCopy, s);
      _softCopy &= u32(0xffffffff);
      _softCopy |= u32(0x0);
      markClean(s);
   }
}

inline void tDO::tDO_Trigger_Select_Register::writeRegister(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   force = force || (_softCopy != fieldValue);
   _softCopy = fieldValue;
   flush(s, force);
}

inline u32 tDO::tDO_Trigger_Select_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tDO::tDO_Trigger_Select_Register& tDO::tDO_Trigger_Select_Register::setDO_External_Gate_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffeff) | ((u32(fieldValue) << 0x8) & ~0xfffffeff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tDO::tDO_Trigger_Select_Register::getDO_External_Gate_Enable(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xfffffeff) >> 0x8);
}

inline void tDO::tDO_Trigger_Select_Register::writeDO_External_Gate_Enable(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_External_Gate_Enable(fieldValue, s);
   flush(s, force);
}
inline u32 tDO::tDO_Trigger_Select_Register::readDO_External_Gate_Enable(nMDBG::tStatus2* s)
{
   return getDO_External_Gate_Enable(s);
}

inline tDO::tDO_Trigger_Select_Register& tDO::tDO_Trigger_Select_Register::setDO_External_Gate_Polarity(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffdff) | ((u32(fieldValue) << 0x9) & ~0xfffffdff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tDO::tDO_Trigger_Select_Register::getDO_External_Gate_Polarity(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xfffffdff) >> 0x9);
}

inline void tDO::tDO_Trigger_Select_Register::writeDO_External_Gate_Polarity(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_External_Gate_Polarity(fieldValue, s);
   flush(s, force);
}
inline u32 tDO::tDO_Trigger_Select_Register::readDO_External_Gate_Polarity(nMDBG::tStatus2* s)
{
   return getDO_External_Gate_Polarity(s);
}

inline tDO::tDO_Trigger_Select_Register& tDO::tDO_Trigger_Select_Register::setDO_External_Gate_Select(nDO::tDO_External_Gate_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffff03ff) | ((u32(fieldValue) << 0xa) & ~0xffff03ff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_External_Gate_Select_t tDO::tDO_Trigger_Select_Register::getDO_External_Gate_Select(nMDBG::tStatus2*) const
{
   return nDO::tDO_External_Gate_Select_t((_softCopy & ~0xffff03ff) >> 0xa);
}

inline void tDO::tDO_Trigger_Select_Register::writeDO_External_Gate_Select(nDO::tDO_External_Gate_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_External_Gate_Select(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_External_Gate_Select_t tDO::tDO_Trigger_Select_Register::readDO_External_Gate_Select(nMDBG::tStatus2* s)
{
   return getDO_External_Gate_Select(s);
}

inline tDO::tDO_Trigger_Select_Register& tDO::tDO_Trigger_Select_Register::setDO_START1_Edge(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffeffff) | ((u32(fieldValue) << 0x10) & ~0xfffeffff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tDO::tDO_Trigger_Select_Register::getDO_START1_Edge(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xfffeffff) >> 0x10);
}

inline void tDO::tDO_Trigger_Select_Register::writeDO_START1_Edge(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_START1_Edge(fieldValue, s);
   flush(s, force);
}
inline u32 tDO::tDO_Trigger_Select_Register::readDO_START1_Edge(nMDBG::tStatus2* s)
{
   return getDO_START1_Edge(s);
}

inline tDO::tDO_Trigger_Select_Register& tDO::tDO_Trigger_Select_Register::setDO_START1_Polarity(nDO::tDO_Polarity_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffdffff) | ((u32(fieldValue) << 0x11) & ~0xfffdffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_Polarity_t tDO::tDO_Trigger_Select_Register::getDO_START1_Polarity(nMDBG::tStatus2*) const
{
   return nDO::tDO_Polarity_t((_softCopy & ~0xfffdffff) >> 0x11);
}

inline void tDO::tDO_Trigger_Select_Register::writeDO_START1_Polarity(nDO::tDO_Polarity_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_START1_Polarity(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_Polarity_t tDO::tDO_Trigger_Select_Register::readDO_START1_Polarity(nMDBG::tStatus2* s)
{
   return getDO_START1_Polarity(s);
}

inline tDO::tDO_Trigger_Select_Register& tDO::tDO_Trigger_Select_Register::setDO_START1_Select(nDO::tDO_START1_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xff03ffff) | ((u32(fieldValue) << 0x12) & ~0xff03ffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_START1_Select_t tDO::tDO_Trigger_Select_Register::getDO_START1_Select(nMDBG::tStatus2*) const
{
   return nDO::tDO_START1_Select_t((_softCopy & ~0xff03ffff) >> 0x12);
}

inline void tDO::tDO_Trigger_Select_Register::writeDO_START1_Select(nDO::tDO_START1_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_START1_Select(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_START1_Select_t tDO::tDO_Trigger_Select_Register::readDO_START1_Select(nMDBG::tStatus2* s)
{
   return getDO_START1_Select(s);
}

inline tDO::tDO_Trigger_Select_Register& tDO::tDO_Trigger_Select_Register::setDO_UPDATE_Source_Polarity(nDO::tDO_Polarity_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfdffffff) | ((u32(fieldValue) << 0x19) & ~0xfdffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_Polarity_t tDO::tDO_Trigger_Select_Register::getDO_UPDATE_Source_Polarity(nMDBG::tStatus2*) const
{
   return nDO::tDO_Polarity_t((_softCopy & ~0xfdffffff) >> 0x19);
}

inline void tDO::tDO_Trigger_Select_Register::writeDO_UPDATE_Source_Polarity(nDO::tDO_Polarity_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_UPDATE_Source_Polarity(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_Polarity_t tDO::tDO_Trigger_Select_Register::readDO_UPDATE_Source_Polarity(nMDBG::tStatus2* s)
{
   return getDO_UPDATE_Source_Polarity(s);
}

inline tDO::tDO_Trigger_Select_Register& tDO::tDO_Trigger_Select_Register::setDO_UPDATE_Source_Select(nDO::tDO_UPDATE_Source_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0x3ffffff) | ((u32(fieldValue) << 0x1a) & ~0x3ffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_UPDATE_Source_Select_t tDO::tDO_Trigger_Select_Register::getDO_UPDATE_Source_Select(nMDBG::tStatus2*) const
{
   return nDO::tDO_UPDATE_Source_Select_t((_softCopy & ~0x3ffffff) >> 0x1a);
}

inline void tDO::tDO_Trigger_Select_Register::writeDO_UPDATE_Source_Select(nDO::tDO_UPDATE_Source_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_UPDATE_Source_Select(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_UPDATE_Source_Select_t tDO::tDO_Trigger_Select_Register::readDO_UPDATE_Source_Select(nMDBG::tStatus2* s)
{
   return getDO_UPDATE_Source_Select(s);
}

inline tDO::tDO_DirectDataRegister::tDO_DirectDataRegister()
{
}

inline tDO::tDO_DirectDataRegister::tRegisterMap* tDO::tDO_DirectDataRegister::registerMap(void)
{
   return _regMap;
}

inline void tDO::tDO_DirectDataRegister::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline void tDO::tDO_DirectDataRegister::writeRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), fieldValue, s);
}

inline void tDO::tDO_DirectDataRegister::writeCDO_Direct_data(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x0) & ~0x0,s);
}
inline tDO::tDO_WDT_SafeStateRegister::tDO_WDT_SafeStateRegister()
{
   _softCopy = u32(0x0);
}

inline tDO::tDO_WDT_SafeStateRegister::tRegisterMap* tDO::tDO_WDT_SafeStateRegister::registerMap(void)
{
   return _regMap;
}

inline void tDO::tDO_WDT_SafeStateRegister::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tBoolean tDO::tDO_WDT_SafeStateRegister::isDirty(nMDBG::tStatus2* s)
{
   return _regMap->isDirty((tDO::tId)kId, s);
}

inline void tDO::tDO_WDT_SafeStateRegister::markDirty(nMDBG::tStatus2* s)
{
   _regMap->markDirty((tDO::tId)kId, s);
}

inline void tDO::tDO_WDT_SafeStateRegister::markClean(nMDBG::tStatus2* s)
{
   _regMap->markClean((tDO::tId)kId, s);
}

inline tDO::tDO_WDT_SafeStateRegister& tDO::tDO_WDT_SafeStateRegister::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   if (_softCopy != fieldValue) {
      _softCopy = fieldValue;
      markDirty(s);
   }
   return *this;
}

inline u32 tDO::tDO_WDT_SafeStateRegister::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tDO::tDO_WDT_SafeStateRegister::flush(nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   if (force || isDirty(s)) {
      tIOStrategy::write(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), _softCopy, s);
      _softCopy &= u32(0xffffffff);
      _softCopy |= u32(0x0);
      markClean(s);
   }
}

inline void tDO::tDO_WDT_SafeStateRegister::writeRegister(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   force = force || (_softCopy != fieldValue);
   _softCopy = fieldValue;
   flush(s, force);
}

inline u32 tDO::tDO_WDT_SafeStateRegister::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tDO::tDO_WDT_SafeStateRegister& tDO::tDO_WDT_SafeStateRegister::setDO_WDT_SafeStateValue(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0x0) | ((u32(fieldValue) << 0x0) & ~0x0);
   setRegister(newValue, s);
   return *this;
}

inline u32 tDO::tDO_WDT_SafeStateRegister::getDO_WDT_SafeStateValue(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline tDO::tDO_WDT_SafeStateRegister& tDO::tDO_WDT_SafeStateRegister::setDO_WDT_SafeStateValue(u32 position, tBoolean bitValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & ~(u32(0x1) << (0x0 + position))) | (u32(bitValue) << (0x0 + position));
   setRegister(newValue, s);
   return *this;
}

inline tBoolean tDO::tDO_WDT_SafeStateRegister::getDO_WDT_SafeStateValue(u32 position, nMDBG::tStatus2*) const
{
   return (_softCopy >> (0x0 + position)) & 0x1;
}

inline void tDO::tDO_WDT_SafeStateRegister::writeDO_WDT_SafeStateValue(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_SafeStateValue(fieldValue, s);
   flush(s, force);
}
inline void tDO::tDO_WDT_SafeStateRegister::writeDO_WDT_SafeStateValue(u32 position, tBoolean bitValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_SafeStateValue(position, bitValue, s);
   flush(s, force);
}
inline u32 tDO::tDO_WDT_SafeStateRegister::readDO_WDT_SafeStateValue(nMDBG::tStatus2* s)
{
   return getDO_WDT_SafeStateValue(s);
}

inline tBoolean tDO::tDO_WDT_SafeStateRegister::readDO_WDT_SafeStateValue(u32 position, nMDBG::tStatus2* s)
{
   return getDO_WDT_SafeStateValue(position, s);
}

inline tDO::tDO_WDT_ModeSelect1_Register::tDO_WDT_ModeSelect1_Register()
{
   _softCopy = u32(0x0);
}

inline tDO::tDO_WDT_ModeSelect1_Register::tRegisterMap* tDO::tDO_WDT_ModeSelect1_Register::registerMap(void)
{
   return _regMap;
}

inline void tDO::tDO_WDT_ModeSelect1_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tBoolean tDO::tDO_WDT_ModeSelect1_Register::isDirty(nMDBG::tStatus2* s)
{
   return _regMap->isDirty((tDO::tId)kId, s);
}

inline void tDO::tDO_WDT_ModeSelect1_Register::markDirty(nMDBG::tStatus2* s)
{
   _regMap->markDirty((tDO::tId)kId, s);
}

inline void tDO::tDO_WDT_ModeSelect1_Register::markClean(nMDBG::tStatus2* s)
{
   _regMap->markClean((tDO::tId)kId, s);
}

inline tDO::tDO_WDT_ModeSelect1_Register& tDO::tDO_WDT_ModeSelect1_Register::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   if (_softCopy != fieldValue) {
      _softCopy = fieldValue;
      markDirty(s);
   }
   return *this;
}

inline u32 tDO::tDO_WDT_ModeSelect1_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tDO::tDO_WDT_ModeSelect1_Register::flush(nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   if (force || isDirty(s)) {
      tIOStrategy::write(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), _softCopy, s);
      _softCopy &= u32(0xffffffff);
      _softCopy |= u32(0x0);
      markClean(s);
   }
}

inline void tDO::tDO_WDT_ModeSelect1_Register::writeRegister(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   force = force || (_softCopy != fieldValue);
   _softCopy = fieldValue;
   flush(s, force);
}

inline u32 tDO::tDO_WDT_ModeSelect1_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tDO::tDO_WDT_ModeSelect1_Register& tDO::tDO_WDT_ModeSelect1_Register::setDO_WDT_ModeD0(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffffc) | ((u32(fieldValue) << 0x0) & ~0xfffffffc);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::getDO_WDT_ModeD0(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xfffffffc) >> 0x0);
}

inline void tDO::tDO_WDT_ModeSelect1_Register::writeDO_WDT_ModeD0(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD0(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::readDO_WDT_ModeD0(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD0(s);
}

inline tDO::tDO_WDT_ModeSelect1_Register& tDO::tDO_WDT_ModeSelect1_Register::setDO_WDT_ModeD1(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffff3) | ((u32(fieldValue) << 0x2) & ~0xfffffff3);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::getDO_WDT_ModeD1(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xfffffff3) >> 0x2);
}

inline void tDO::tDO_WDT_ModeSelect1_Register::writeDO_WDT_ModeD1(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD1(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::readDO_WDT_ModeD1(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD1(s);
}

inline tDO::tDO_WDT_ModeSelect1_Register& tDO::tDO_WDT_ModeSelect1_Register::setDO_WDT_ModeD2(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffffcf) | ((u32(fieldValue) << 0x4) & ~0xffffffcf);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::getDO_WDT_ModeD2(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xffffffcf) >> 0x4);
}

inline void tDO::tDO_WDT_ModeSelect1_Register::writeDO_WDT_ModeD2(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD2(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::readDO_WDT_ModeD2(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD2(s);
}

inline tDO::tDO_WDT_ModeSelect1_Register& tDO::tDO_WDT_ModeSelect1_Register::setDO_WDT_ModeD3(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffff3f) | ((u32(fieldValue) << 0x6) & ~0xffffff3f);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::getDO_WDT_ModeD3(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xffffff3f) >> 0x6);
}

inline void tDO::tDO_WDT_ModeSelect1_Register::writeDO_WDT_ModeD3(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD3(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::readDO_WDT_ModeD3(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD3(s);
}

inline tDO::tDO_WDT_ModeSelect1_Register& tDO::tDO_WDT_ModeSelect1_Register::setDO_WDT_ModeD4(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffcff) | ((u32(fieldValue) << 0x8) & ~0xfffffcff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::getDO_WDT_ModeD4(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xfffffcff) >> 0x8);
}

inline void tDO::tDO_WDT_ModeSelect1_Register::writeDO_WDT_ModeD4(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD4(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::readDO_WDT_ModeD4(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD4(s);
}

inline tDO::tDO_WDT_ModeSelect1_Register& tDO::tDO_WDT_ModeSelect1_Register::setDO_WDT_ModeD5(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffff3ff) | ((u32(fieldValue) << 0xa) & ~0xfffff3ff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::getDO_WDT_ModeD5(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xfffff3ff) >> 0xa);
}

inline void tDO::tDO_WDT_ModeSelect1_Register::writeDO_WDT_ModeD5(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD5(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::readDO_WDT_ModeD5(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD5(s);
}

inline tDO::tDO_WDT_ModeSelect1_Register& tDO::tDO_WDT_ModeSelect1_Register::setDO_WDT_ModeD6(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffcfff) | ((u32(fieldValue) << 0xc) & ~0xffffcfff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::getDO_WDT_ModeD6(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xffffcfff) >> 0xc);
}

inline void tDO::tDO_WDT_ModeSelect1_Register::writeDO_WDT_ModeD6(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD6(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::readDO_WDT_ModeD6(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD6(s);
}

inline tDO::tDO_WDT_ModeSelect1_Register& tDO::tDO_WDT_ModeSelect1_Register::setDO_WDT_ModeD7(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffff3fff) | ((u32(fieldValue) << 0xe) & ~0xffff3fff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::getDO_WDT_ModeD7(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xffff3fff) >> 0xe);
}

inline void tDO::tDO_WDT_ModeSelect1_Register::writeDO_WDT_ModeD7(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD7(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::readDO_WDT_ModeD7(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD7(s);
}

inline tDO::tDO_WDT_ModeSelect1_Register& tDO::tDO_WDT_ModeSelect1_Register::setDO_WDT_ModeD8(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffcffff) | ((u32(fieldValue) << 0x10) & ~0xfffcffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::getDO_WDT_ModeD8(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xfffcffff) >> 0x10);
}

inline void tDO::tDO_WDT_ModeSelect1_Register::writeDO_WDT_ModeD8(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD8(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::readDO_WDT_ModeD8(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD8(s);
}

inline tDO::tDO_WDT_ModeSelect1_Register& tDO::tDO_WDT_ModeSelect1_Register::setDO_WDT_ModeD9(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfff3ffff) | ((u32(fieldValue) << 0x12) & ~0xfff3ffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::getDO_WDT_ModeD9(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xfff3ffff) >> 0x12);
}

inline void tDO::tDO_WDT_ModeSelect1_Register::writeDO_WDT_ModeD9(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD9(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::readDO_WDT_ModeD9(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD9(s);
}

inline tDO::tDO_WDT_ModeSelect1_Register& tDO::tDO_WDT_ModeSelect1_Register::setDO_WDT_ModeD10(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffcfffff) | ((u32(fieldValue) << 0x14) & ~0xffcfffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::getDO_WDT_ModeD10(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xffcfffff) >> 0x14);
}

inline void tDO::tDO_WDT_ModeSelect1_Register::writeDO_WDT_ModeD10(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD10(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::readDO_WDT_ModeD10(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD10(s);
}

inline tDO::tDO_WDT_ModeSelect1_Register& tDO::tDO_WDT_ModeSelect1_Register::setDO_WDT_ModeD11(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xff3fffff) | ((u32(fieldValue) << 0x16) & ~0xff3fffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::getDO_WDT_ModeD11(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xff3fffff) >> 0x16);
}

inline void tDO::tDO_WDT_ModeSelect1_Register::writeDO_WDT_ModeD11(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD11(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::readDO_WDT_ModeD11(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD11(s);
}

inline tDO::tDO_WDT_ModeSelect1_Register& tDO::tDO_WDT_ModeSelect1_Register::setDO_WDT_ModeD12(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfcffffff) | ((u32(fieldValue) << 0x18) & ~0xfcffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::getDO_WDT_ModeD12(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xfcffffff) >> 0x18);
}

inline void tDO::tDO_WDT_ModeSelect1_Register::writeDO_WDT_ModeD12(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD12(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::readDO_WDT_ModeD12(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD12(s);
}

inline tDO::tDO_WDT_ModeSelect1_Register& tDO::tDO_WDT_ModeSelect1_Register::setDO_WDT_ModeD13(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xf3ffffff) | ((u32(fieldValue) << 0x1a) & ~0xf3ffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::getDO_WDT_ModeD13(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xf3ffffff) >> 0x1a);
}

inline void tDO::tDO_WDT_ModeSelect1_Register::writeDO_WDT_ModeD13(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD13(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::readDO_WDT_ModeD13(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD13(s);
}

inline tDO::tDO_WDT_ModeSelect1_Register& tDO::tDO_WDT_ModeSelect1_Register::setDO_WDT_ModeD14(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xcfffffff) | ((u32(fieldValue) << 0x1c) & ~0xcfffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::getDO_WDT_ModeD14(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xcfffffff) >> 0x1c);
}

inline void tDO::tDO_WDT_ModeSelect1_Register::writeDO_WDT_ModeD14(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD14(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::readDO_WDT_ModeD14(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD14(s);
}

inline tDO::tDO_WDT_ModeSelect1_Register& tDO::tDO_WDT_ModeSelect1_Register::setDO_WDT_ModeD15(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0x3fffffff) | ((u32(fieldValue) << 0x1e) & ~0x3fffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::getDO_WDT_ModeD15(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0x3fffffff) >> 0x1e);
}

inline void tDO::tDO_WDT_ModeSelect1_Register::writeDO_WDT_ModeD15(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD15(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect1_Register::readDO_WDT_ModeD15(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD15(s);
}

inline tDO::tDO_WDT_ModeSelect2_Register::tDO_WDT_ModeSelect2_Register()
{
   _softCopy = u32(0x0);
}

inline tDO::tDO_WDT_ModeSelect2_Register::tRegisterMap* tDO::tDO_WDT_ModeSelect2_Register::registerMap(void)
{
   return _regMap;
}

inline void tDO::tDO_WDT_ModeSelect2_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tBoolean tDO::tDO_WDT_ModeSelect2_Register::isDirty(nMDBG::tStatus2* s)
{
   return _regMap->isDirty((tDO::tId)kId, s);
}

inline void tDO::tDO_WDT_ModeSelect2_Register::markDirty(nMDBG::tStatus2* s)
{
   _regMap->markDirty((tDO::tId)kId, s);
}

inline void tDO::tDO_WDT_ModeSelect2_Register::markClean(nMDBG::tStatus2* s)
{
   _regMap->markClean((tDO::tId)kId, s);
}

inline tDO::tDO_WDT_ModeSelect2_Register& tDO::tDO_WDT_ModeSelect2_Register::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   if (_softCopy != fieldValue) {
      _softCopy = fieldValue;
      markDirty(s);
   }
   return *this;
}

inline u32 tDO::tDO_WDT_ModeSelect2_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tDO::tDO_WDT_ModeSelect2_Register::flush(nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   if (force || isDirty(s)) {
      tIOStrategy::write(_regMap->getBusSpaceReference(), kOffset + _regMap->getAddressOffset(s), _softCopy, s);
      _softCopy &= u32(0xffffffff);
      _softCopy |= u32(0x0);
      markClean(s);
   }
}

inline void tDO::tDO_WDT_ModeSelect2_Register::writeRegister(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   force = force || (_softCopy != fieldValue);
   _softCopy = fieldValue;
   flush(s, force);
}

inline u32 tDO::tDO_WDT_ModeSelect2_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tDO::tDO_WDT_ModeSelect2_Register& tDO::tDO_WDT_ModeSelect2_Register::setDO_WDT_ModeD16(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffffc) | ((u32(fieldValue) << 0x0) & ~0xfffffffc);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::getDO_WDT_ModeD16(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xfffffffc) >> 0x0);
}

inline void tDO::tDO_WDT_ModeSelect2_Register::writeDO_WDT_ModeD16(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD16(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::readDO_WDT_ModeD16(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD16(s);
}

inline tDO::tDO_WDT_ModeSelect2_Register& tDO::tDO_WDT_ModeSelect2_Register::setDO_WDT_ModeD17(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffff3) | ((u32(fieldValue) << 0x2) & ~0xfffffff3);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::getDO_WDT_ModeD17(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xfffffff3) >> 0x2);
}

inline void tDO::tDO_WDT_ModeSelect2_Register::writeDO_WDT_ModeD17(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD17(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::readDO_WDT_ModeD17(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD17(s);
}

inline tDO::tDO_WDT_ModeSelect2_Register& tDO::tDO_WDT_ModeSelect2_Register::setDO_WDT_ModeD18(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffffcf) | ((u32(fieldValue) << 0x4) & ~0xffffffcf);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::getDO_WDT_ModeD18(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xffffffcf) >> 0x4);
}

inline void tDO::tDO_WDT_ModeSelect2_Register::writeDO_WDT_ModeD18(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD18(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::readDO_WDT_ModeD18(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD18(s);
}

inline tDO::tDO_WDT_ModeSelect2_Register& tDO::tDO_WDT_ModeSelect2_Register::setDO_WDT_ModeD19(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffff3f) | ((u32(fieldValue) << 0x6) & ~0xffffff3f);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::getDO_WDT_ModeD19(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xffffff3f) >> 0x6);
}

inline void tDO::tDO_WDT_ModeSelect2_Register::writeDO_WDT_ModeD19(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD19(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::readDO_WDT_ModeD19(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD19(s);
}

inline tDO::tDO_WDT_ModeSelect2_Register& tDO::tDO_WDT_ModeSelect2_Register::setDO_WDT_ModeD20(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffcff) | ((u32(fieldValue) << 0x8) & ~0xfffffcff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::getDO_WDT_ModeD20(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xfffffcff) >> 0x8);
}

inline void tDO::tDO_WDT_ModeSelect2_Register::writeDO_WDT_ModeD20(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD20(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::readDO_WDT_ModeD20(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD20(s);
}

inline tDO::tDO_WDT_ModeSelect2_Register& tDO::tDO_WDT_ModeSelect2_Register::setDO_WDT_ModeD21(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffff3ff) | ((u32(fieldValue) << 0xa) & ~0xfffff3ff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::getDO_WDT_ModeD21(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xfffff3ff) >> 0xa);
}

inline void tDO::tDO_WDT_ModeSelect2_Register::writeDO_WDT_ModeD21(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD21(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::readDO_WDT_ModeD21(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD21(s);
}

inline tDO::tDO_WDT_ModeSelect2_Register& tDO::tDO_WDT_ModeSelect2_Register::setDO_WDT_ModeD22(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffcfff) | ((u32(fieldValue) << 0xc) & ~0xffffcfff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::getDO_WDT_ModeD22(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xffffcfff) >> 0xc);
}

inline void tDO::tDO_WDT_ModeSelect2_Register::writeDO_WDT_ModeD22(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD22(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::readDO_WDT_ModeD22(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD22(s);
}

inline tDO::tDO_WDT_ModeSelect2_Register& tDO::tDO_WDT_ModeSelect2_Register::setDO_WDT_ModeD23(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffff3fff) | ((u32(fieldValue) << 0xe) & ~0xffff3fff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::getDO_WDT_ModeD23(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xffff3fff) >> 0xe);
}

inline void tDO::tDO_WDT_ModeSelect2_Register::writeDO_WDT_ModeD23(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD23(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::readDO_WDT_ModeD23(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD23(s);
}

inline tDO::tDO_WDT_ModeSelect2_Register& tDO::tDO_WDT_ModeSelect2_Register::setDO_WDT_ModeD24(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffcffff) | ((u32(fieldValue) << 0x10) & ~0xfffcffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::getDO_WDT_ModeD24(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xfffcffff) >> 0x10);
}

inline void tDO::tDO_WDT_ModeSelect2_Register::writeDO_WDT_ModeD24(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD24(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::readDO_WDT_ModeD24(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD24(s);
}

inline tDO::tDO_WDT_ModeSelect2_Register& tDO::tDO_WDT_ModeSelect2_Register::setDO_WDT_ModeD25(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfff3ffff) | ((u32(fieldValue) << 0x12) & ~0xfff3ffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::getDO_WDT_ModeD25(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xfff3ffff) >> 0x12);
}

inline void tDO::tDO_WDT_ModeSelect2_Register::writeDO_WDT_ModeD25(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD25(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::readDO_WDT_ModeD25(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD25(s);
}

inline tDO::tDO_WDT_ModeSelect2_Register& tDO::tDO_WDT_ModeSelect2_Register::setDO_WDT_ModeD26(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffcfffff) | ((u32(fieldValue) << 0x14) & ~0xffcfffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::getDO_WDT_ModeD26(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xffcfffff) >> 0x14);
}

inline void tDO::tDO_WDT_ModeSelect2_Register::writeDO_WDT_ModeD26(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD26(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::readDO_WDT_ModeD26(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD26(s);
}

inline tDO::tDO_WDT_ModeSelect2_Register& tDO::tDO_WDT_ModeSelect2_Register::setDO_WDT_ModeD27(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xff3fffff) | ((u32(fieldValue) << 0x16) & ~0xff3fffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::getDO_WDT_ModeD27(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xff3fffff) >> 0x16);
}

inline void tDO::tDO_WDT_ModeSelect2_Register::writeDO_WDT_ModeD27(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD27(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::readDO_WDT_ModeD27(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD27(s);
}

inline tDO::tDO_WDT_ModeSelect2_Register& tDO::tDO_WDT_ModeSelect2_Register::setDO_WDT_ModeD28(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfcffffff) | ((u32(fieldValue) << 0x18) & ~0xfcffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::getDO_WDT_ModeD28(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xfcffffff) >> 0x18);
}

inline void tDO::tDO_WDT_ModeSelect2_Register::writeDO_WDT_ModeD28(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD28(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::readDO_WDT_ModeD28(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD28(s);
}

inline tDO::tDO_WDT_ModeSelect2_Register& tDO::tDO_WDT_ModeSelect2_Register::setDO_WDT_ModeD29(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xf3ffffff) | ((u32(fieldValue) << 0x1a) & ~0xf3ffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::getDO_WDT_ModeD29(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xf3ffffff) >> 0x1a);
}

inline void tDO::tDO_WDT_ModeSelect2_Register::writeDO_WDT_ModeD29(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD29(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::readDO_WDT_ModeD29(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD29(s);
}

inline tDO::tDO_WDT_ModeSelect2_Register& tDO::tDO_WDT_ModeSelect2_Register::setDO_WDT_ModeD30(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xcfffffff) | ((u32(fieldValue) << 0x1c) & ~0xcfffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::getDO_WDT_ModeD30(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0xcfffffff) >> 0x1c);
}

inline void tDO::tDO_WDT_ModeSelect2_Register::writeDO_WDT_ModeD30(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD30(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::readDO_WDT_ModeD30(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD30(s);
}

inline tDO::tDO_WDT_ModeSelect2_Register& tDO::tDO_WDT_ModeSelect2_Register::setDO_WDT_ModeD31(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0x3fffffff) | ((u32(fieldValue) << 0x1e) & ~0x3fffffff);
   setRegister(newValue, s);
   return *this;
}

inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::getDO_WDT_ModeD31(nMDBG::tStatus2*) const
{
   return nDO::tDO_WDT_Mode_t((_softCopy & ~0x3fffffff) >> 0x1e);
}

inline void tDO::tDO_WDT_ModeSelect2_Register::writeDO_WDT_ModeD31(nDO::tDO_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDO_WDT_ModeD31(fieldValue, s);
   flush(s, force);
}
inline nDO::tDO_WDT_Mode_t tDO::tDO_WDT_ModeSelect2_Register::readDO_WDT_ModeD31(nMDBG::tStatus2* s)
{
   return getDO_WDT_ModeD31(s);
}

#endif


// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// This file is autogenerated!!!
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!