// 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 ___tTriggers_ipp___
#define ___tTriggers_ipp___

#ifndef ___tTriggers_h___
#include "tTriggers.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 tTriggers::tReg8IODirect32::write(
   tBusSpaceReference addrSpace,
   u32 offset,
   u8 value,
   nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   addrSpace.write8(offset, value);
}
inline u8 tTriggers::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 tTriggers::tReg16IODirect32::write(
   tBusSpaceReference addrSpace,
   u32 offset,
   u16 value,
   nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   addrSpace.write16(offset, value);
}

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

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

inline u32 tTriggers::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 tTriggers::getBusSpaceReference(void) const
{
   return _addrSpace;
}

inline void tTriggers::setAddressOffset(u32 value, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _addressOffset = value;
}
inline u32 tTriggers::getAddressOffset(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return 0UL;
   return _addressOffset;
}
inline tBoolean tTriggers::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 tTriggers::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 tTriggers::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 tTriggers::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 tTriggers::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 tTriggers::tAnalogTrigControlRegister::tAnalogTrigControlRegister()
{
   _softCopy = u16(0x0);
}

inline tTriggers::tAnalogTrigControlRegister::tRegisterMap* tTriggers::tAnalogTrigControlRegister::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tAnalogTrigControlRegister::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tTriggers::tAnalogTrigControlRegister::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tTriggers::tAnalogTrigControlRegister::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 &= u16(0xffdf);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tTriggers::tAnalogTrigControlRegister::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tTriggers::tAnalogTrigControlRegister& tTriggers::tAnalogTrigControlRegister::setAnalog_Trigger_Mode(nTriggers::tTrig_Analog_Trigger_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfff8) | ((u16(fieldValue) << 0x0) & ~0xfff8);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Analog_Trigger_Mode_t tTriggers::tAnalogTrigControlRegister::getAnalog_Trigger_Mode(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Analog_Trigger_Mode_t((_softCopy & ~0xfff8) >> 0x0);
}

inline void tTriggers::tAnalogTrigControlRegister::writeAnalog_Trigger_Mode(nTriggers::tTrig_Analog_Trigger_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setAnalog_Trigger_Mode(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Analog_Trigger_Mode_t tTriggers::tAnalogTrigControlRegister::readAnalog_Trigger_Mode(nMDBG::tStatus2* s)
{
   return getAnalog_Trigger_Mode(s);
}

inline tTriggers::tAnalogTrigControlRegister& tTriggers::tAnalogTrigControlRegister::setAnalog_Trigger_Reset(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xffdf) | ((u16(fieldValue) << 0x5) & ~0xffdf);
   setRegister(newValue, s);
   return *this;
}

inline u16 tTriggers::tAnalogTrigControlRegister::getAnalog_Trigger_Reset(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xffdf) >> 0x5);
}

inline void tTriggers::tAnalogTrigControlRegister::writeAnalog_Trigger_Reset(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setAnalog_Trigger_Reset(fieldValue, s);
   flush(s, force);
}
inline u16 tTriggers::tAnalogTrigControlRegister::readAnalog_Trigger_Reset(nMDBG::tStatus2* s)
{
   return getAnalog_Trigger_Reset(s);
}

inline tTriggers::tAnalogTrigControlRegister& tTriggers::tAnalogTrigControlRegister::setAtrig_Sel(nTriggers::tTrig_Atrig_Sel_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfcff) | ((u16(fieldValue) << 0x8) & ~0xfcff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Atrig_Sel_t tTriggers::tAnalogTrigControlRegister::getAtrig_Sel(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Atrig_Sel_t((_softCopy & ~0xfcff) >> 0x8);
}

inline void tTriggers::tAnalogTrigControlRegister::writeAtrig_Sel(nTriggers::tTrig_Atrig_Sel_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setAtrig_Sel(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Atrig_Sel_t tTriggers::tAnalogTrigControlRegister::readAtrig_Sel(nMDBG::tStatus2* s)
{
   return getAtrig_Sel(s);
}

inline tTriggers::tFOUT_Register::tFOUT_Register()
{
   _softCopy = u16(0x0);
}

inline tTriggers::tFOUT_Register::tRegisterMap* tTriggers::tFOUT_Register::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tFOUT_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tTriggers::tFOUT_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tTriggers::tFOUT_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 &= u16(0xffff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tTriggers::tFOUT_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tTriggers::tFOUT_Register& tTriggers::tFOUT_Register::setFOUT_Divider(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfff0) | ((u16(fieldValue) << 0x0) & ~0xfff0);
   setRegister(newValue, s);
   return *this;
}

inline u16 tTriggers::tFOUT_Register::getFOUT_Divider(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfff0) >> 0x0);
}

inline void tTriggers::tFOUT_Register::writeFOUT_Divider(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setFOUT_Divider(fieldValue, s);
   flush(s, force);
}
inline u16 tTriggers::tFOUT_Register::readFOUT_Divider(nMDBG::tStatus2* s)
{
   return getFOUT_Divider(s);
}

inline tTriggers::tFOUT_Register& tTriggers::tFOUT_Register::setFOUT_FastTB_DivideBy2(nTriggers::tTrig_FOUT_FastTB_DivideBy2_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xefff) | ((u16(fieldValue) << 0xc) & ~0xefff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_FOUT_FastTB_DivideBy2_t tTriggers::tFOUT_Register::getFOUT_FastTB_DivideBy2(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_FOUT_FastTB_DivideBy2_t((_softCopy & ~0xefff) >> 0xc);
}

inline void tTriggers::tFOUT_Register::writeFOUT_FastTB_DivideBy2(nTriggers::tTrig_FOUT_FastTB_DivideBy2_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setFOUT_FastTB_DivideBy2(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_FOUT_FastTB_DivideBy2_t tTriggers::tFOUT_Register::readFOUT_FastTB_DivideBy2(nMDBG::tStatus2* s)
{
   return getFOUT_FastTB_DivideBy2(s);
}

inline tTriggers::tFOUT_Register& tTriggers::tFOUT_Register::setFOUT_Timebase_Select(nTriggers::tTrig_FOUT_Timebase_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xbfff) | ((u16(fieldValue) << 0xe) & ~0xbfff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_FOUT_Timebase_Select_t tTriggers::tFOUT_Register::getFOUT_Timebase_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_FOUT_Timebase_Select_t((_softCopy & ~0xbfff) >> 0xe);
}

inline void tTriggers::tFOUT_Register::writeFOUT_Timebase_Select(nTriggers::tTrig_FOUT_Timebase_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setFOUT_Timebase_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_FOUT_Timebase_Select_t tTriggers::tFOUT_Register::readFOUT_Timebase_Select(nMDBG::tStatus2* s)
{
   return getFOUT_Timebase_Select(s);
}

inline tTriggers::tFOUT_Register& tTriggers::tFOUT_Register::setFOUT_Enable(nTriggers::tTrig_FOUT_Enable_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0x7fff) | ((u16(fieldValue) << 0xf) & ~0x7fff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_FOUT_Enable_t tTriggers::tFOUT_Register::getFOUT_Enable(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_FOUT_Enable_t((_softCopy & ~0x7fff) >> 0xf);
}

inline void tTriggers::tFOUT_Register::writeFOUT_Enable(nTriggers::tTrig_FOUT_Enable_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setFOUT_Enable(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_FOUT_Enable_t tTriggers::tFOUT_Register::readFOUT_Enable(nMDBG::tStatus2* s)
{
   return getFOUT_Enable(s);
}

inline tTriggers::tPFI_Direction_Register::tPFI_Direction_Register()
{
   _softCopy = u16(0x0);
}

inline tTriggers::tPFI_Direction_Register::tRegisterMap* tTriggers::tPFI_Direction_Register::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tPFI_Direction_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tTriggers::tPFI_Direction_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tTriggers::tPFI_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 &= u16(0xffff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tTriggers::tPFI_Direction_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tTriggers::tPFI_Direction_Register& tTriggers::tPFI_Direction_Register::setPFI0_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfffe) | ((u16(fieldValue) << 0x0) & ~0xfffe);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::getPFI0_Pin_Dir(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_PFI_i_Pin_Dir_t((_softCopy & ~0xfffe) >> 0x0);
}

inline void tTriggers::tPFI_Direction_Register::writePFI0_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI0_Pin_Dir(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::readPFI0_Pin_Dir(nMDBG::tStatus2* s)
{
   return getPFI0_Pin_Dir(s);
}

inline tTriggers::tPFI_Direction_Register& tTriggers::tPFI_Direction_Register::setPFI1_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfffd) | ((u16(fieldValue) << 0x1) & ~0xfffd);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::getPFI1_Pin_Dir(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_PFI_i_Pin_Dir_t((_softCopy & ~0xfffd) >> 0x1);
}

inline void tTriggers::tPFI_Direction_Register::writePFI1_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI1_Pin_Dir(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::readPFI1_Pin_Dir(nMDBG::tStatus2* s)
{
   return getPFI1_Pin_Dir(s);
}

inline tTriggers::tPFI_Direction_Register& tTriggers::tPFI_Direction_Register::setPFI2_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfffb) | ((u16(fieldValue) << 0x2) & ~0xfffb);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::getPFI2_Pin_Dir(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_PFI_i_Pin_Dir_t((_softCopy & ~0xfffb) >> 0x2);
}

inline void tTriggers::tPFI_Direction_Register::writePFI2_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI2_Pin_Dir(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::readPFI2_Pin_Dir(nMDBG::tStatus2* s)
{
   return getPFI2_Pin_Dir(s);
}

inline tTriggers::tPFI_Direction_Register& tTriggers::tPFI_Direction_Register::setPFI3_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfff7) | ((u16(fieldValue) << 0x3) & ~0xfff7);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::getPFI3_Pin_Dir(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_PFI_i_Pin_Dir_t((_softCopy & ~0xfff7) >> 0x3);
}

inline void tTriggers::tPFI_Direction_Register::writePFI3_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI3_Pin_Dir(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::readPFI3_Pin_Dir(nMDBG::tStatus2* s)
{
   return getPFI3_Pin_Dir(s);
}

inline tTriggers::tPFI_Direction_Register& tTriggers::tPFI_Direction_Register::setPFI4_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xffef) | ((u16(fieldValue) << 0x4) & ~0xffef);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::getPFI4_Pin_Dir(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_PFI_i_Pin_Dir_t((_softCopy & ~0xffef) >> 0x4);
}

inline void tTriggers::tPFI_Direction_Register::writePFI4_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI4_Pin_Dir(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::readPFI4_Pin_Dir(nMDBG::tStatus2* s)
{
   return getPFI4_Pin_Dir(s);
}

inline tTriggers::tPFI_Direction_Register& tTriggers::tPFI_Direction_Register::setPFI5_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xffdf) | ((u16(fieldValue) << 0x5) & ~0xffdf);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::getPFI5_Pin_Dir(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_PFI_i_Pin_Dir_t((_softCopy & ~0xffdf) >> 0x5);
}

inline void tTriggers::tPFI_Direction_Register::writePFI5_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI5_Pin_Dir(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::readPFI5_Pin_Dir(nMDBG::tStatus2* s)
{
   return getPFI5_Pin_Dir(s);
}

inline tTriggers::tPFI_Direction_Register& tTriggers::tPFI_Direction_Register::setPFI6_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xffbf) | ((u16(fieldValue) << 0x6) & ~0xffbf);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::getPFI6_Pin_Dir(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_PFI_i_Pin_Dir_t((_softCopy & ~0xffbf) >> 0x6);
}

inline void tTriggers::tPFI_Direction_Register::writePFI6_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI6_Pin_Dir(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::readPFI6_Pin_Dir(nMDBG::tStatus2* s)
{
   return getPFI6_Pin_Dir(s);
}

inline tTriggers::tPFI_Direction_Register& tTriggers::tPFI_Direction_Register::setPFI7_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xff7f) | ((u16(fieldValue) << 0x7) & ~0xff7f);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::getPFI7_Pin_Dir(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_PFI_i_Pin_Dir_t((_softCopy & ~0xff7f) >> 0x7);
}

inline void tTriggers::tPFI_Direction_Register::writePFI7_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI7_Pin_Dir(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::readPFI7_Pin_Dir(nMDBG::tStatus2* s)
{
   return getPFI7_Pin_Dir(s);
}

inline tTriggers::tPFI_Direction_Register& tTriggers::tPFI_Direction_Register::setPFI8_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfeff) | ((u16(fieldValue) << 0x8) & ~0xfeff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::getPFI8_Pin_Dir(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_PFI_i_Pin_Dir_t((_softCopy & ~0xfeff) >> 0x8);
}

inline void tTriggers::tPFI_Direction_Register::writePFI8_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI8_Pin_Dir(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::readPFI8_Pin_Dir(nMDBG::tStatus2* s)
{
   return getPFI8_Pin_Dir(s);
}

inline tTriggers::tPFI_Direction_Register& tTriggers::tPFI_Direction_Register::setPFI9_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfdff) | ((u16(fieldValue) << 0x9) & ~0xfdff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::getPFI9_Pin_Dir(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_PFI_i_Pin_Dir_t((_softCopy & ~0xfdff) >> 0x9);
}

inline void tTriggers::tPFI_Direction_Register::writePFI9_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI9_Pin_Dir(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::readPFI9_Pin_Dir(nMDBG::tStatus2* s)
{
   return getPFI9_Pin_Dir(s);
}

inline tTriggers::tPFI_Direction_Register& tTriggers::tPFI_Direction_Register::setPFI10_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfbff) | ((u16(fieldValue) << 0xa) & ~0xfbff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::getPFI10_Pin_Dir(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_PFI_i_Pin_Dir_t((_softCopy & ~0xfbff) >> 0xa);
}

inline void tTriggers::tPFI_Direction_Register::writePFI10_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI10_Pin_Dir(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::readPFI10_Pin_Dir(nMDBG::tStatus2* s)
{
   return getPFI10_Pin_Dir(s);
}

inline tTriggers::tPFI_Direction_Register& tTriggers::tPFI_Direction_Register::setPFI11_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xf7ff) | ((u16(fieldValue) << 0xb) & ~0xf7ff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::getPFI11_Pin_Dir(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_PFI_i_Pin_Dir_t((_softCopy & ~0xf7ff) >> 0xb);
}

inline void tTriggers::tPFI_Direction_Register::writePFI11_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI11_Pin_Dir(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::readPFI11_Pin_Dir(nMDBG::tStatus2* s)
{
   return getPFI11_Pin_Dir(s);
}

inline tTriggers::tPFI_Direction_Register& tTriggers::tPFI_Direction_Register::setPFI12_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xefff) | ((u16(fieldValue) << 0xc) & ~0xefff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::getPFI12_Pin_Dir(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_PFI_i_Pin_Dir_t((_softCopy & ~0xefff) >> 0xc);
}

inline void tTriggers::tPFI_Direction_Register::writePFI12_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI12_Pin_Dir(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::readPFI12_Pin_Dir(nMDBG::tStatus2* s)
{
   return getPFI12_Pin_Dir(s);
}

inline tTriggers::tPFI_Direction_Register& tTriggers::tPFI_Direction_Register::setPFI13_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xdfff) | ((u16(fieldValue) << 0xd) & ~0xdfff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::getPFI13_Pin_Dir(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_PFI_i_Pin_Dir_t((_softCopy & ~0xdfff) >> 0xd);
}

inline void tTriggers::tPFI_Direction_Register::writePFI13_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI13_Pin_Dir(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::readPFI13_Pin_Dir(nMDBG::tStatus2* s)
{
   return getPFI13_Pin_Dir(s);
}

inline tTriggers::tPFI_Direction_Register& tTriggers::tPFI_Direction_Register::setPFI14_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xbfff) | ((u16(fieldValue) << 0xe) & ~0xbfff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::getPFI14_Pin_Dir(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_PFI_i_Pin_Dir_t((_softCopy & ~0xbfff) >> 0xe);
}

inline void tTriggers::tPFI_Direction_Register::writePFI14_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI14_Pin_Dir(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::readPFI14_Pin_Dir(nMDBG::tStatus2* s)
{
   return getPFI14_Pin_Dir(s);
}

inline tTriggers::tPFI_Direction_Register& tTriggers::tPFI_Direction_Register::setPFI15_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0x7fff) | ((u16(fieldValue) << 0xf) & ~0x7fff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::getPFI15_Pin_Dir(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_PFI_i_Pin_Dir_t((_softCopy & ~0x7fff) >> 0xf);
}

inline void tTriggers::tPFI_Direction_Register::writePFI15_Pin_Dir(nTriggers::tTrig_PFI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI15_Pin_Dir(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_PFI_i_Pin_Dir_t tTriggers::tPFI_Direction_Register::readPFI15_Pin_Dir(nMDBG::tStatus2* s)
{
   return getPFI15_Pin_Dir(s);
}

inline tTriggers::tRTSI_Trig_Direction_Register::tRTSI_Trig_Direction_Register()
{
   _softCopy = u16(0x0);
}

inline tTriggers::tRTSI_Trig_Direction_Register::tRegisterMap* tTriggers::tRTSI_Trig_Direction_Register::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tRTSI_Trig_Direction_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tTriggers::tRTSI_Trig_Direction_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tTriggers::tRTSI_Trig_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 &= u16(0xffff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tTriggers::tRTSI_Trig_Direction_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tTriggers::tRTSI_Trig_Direction_Register& tTriggers::tRTSI_Trig_Direction_Register::setRTSI0_Pin_Dir(nTriggers::tTrig_RTSI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfeff) | ((u16(fieldValue) << 0x8) & ~0xfeff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_RTSI_i_Pin_Dir_t tTriggers::tRTSI_Trig_Direction_Register::getRTSI0_Pin_Dir(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_RTSI_i_Pin_Dir_t((_softCopy & ~0xfeff) >> 0x8);
}

inline void tTriggers::tRTSI_Trig_Direction_Register::writeRTSI0_Pin_Dir(nTriggers::tTrig_RTSI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setRTSI0_Pin_Dir(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_RTSI_i_Pin_Dir_t tTriggers::tRTSI_Trig_Direction_Register::readRTSI0_Pin_Dir(nMDBG::tStatus2* s)
{
   return getRTSI0_Pin_Dir(s);
}

inline tTriggers::tRTSI_Trig_Direction_Register& tTriggers::tRTSI_Trig_Direction_Register::setRTSI1_Pin_Dir(nTriggers::tTrig_RTSI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfdff) | ((u16(fieldValue) << 0x9) & ~0xfdff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_RTSI_i_Pin_Dir_t tTriggers::tRTSI_Trig_Direction_Register::getRTSI1_Pin_Dir(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_RTSI_i_Pin_Dir_t((_softCopy & ~0xfdff) >> 0x9);
}

inline void tTriggers::tRTSI_Trig_Direction_Register::writeRTSI1_Pin_Dir(nTriggers::tTrig_RTSI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setRTSI1_Pin_Dir(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_RTSI_i_Pin_Dir_t tTriggers::tRTSI_Trig_Direction_Register::readRTSI1_Pin_Dir(nMDBG::tStatus2* s)
{
   return getRTSI1_Pin_Dir(s);
}

inline tTriggers::tRTSI_Trig_Direction_Register& tTriggers::tRTSI_Trig_Direction_Register::setRTSI2_Pin_Dir(nTriggers::tTrig_RTSI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfbff) | ((u16(fieldValue) << 0xa) & ~0xfbff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_RTSI_i_Pin_Dir_t tTriggers::tRTSI_Trig_Direction_Register::getRTSI2_Pin_Dir(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_RTSI_i_Pin_Dir_t((_softCopy & ~0xfbff) >> 0xa);
}

inline void tTriggers::tRTSI_Trig_Direction_Register::writeRTSI2_Pin_Dir(nTriggers::tTrig_RTSI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setRTSI2_Pin_Dir(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_RTSI_i_Pin_Dir_t tTriggers::tRTSI_Trig_Direction_Register::readRTSI2_Pin_Dir(nMDBG::tStatus2* s)
{
   return getRTSI2_Pin_Dir(s);
}

inline tTriggers::tRTSI_Trig_Direction_Register& tTriggers::tRTSI_Trig_Direction_Register::setRTSI3_Pin_Dir(nTriggers::tTrig_RTSI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xf7ff) | ((u16(fieldValue) << 0xb) & ~0xf7ff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_RTSI_i_Pin_Dir_t tTriggers::tRTSI_Trig_Direction_Register::getRTSI3_Pin_Dir(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_RTSI_i_Pin_Dir_t((_softCopy & ~0xf7ff) >> 0xb);
}

inline void tTriggers::tRTSI_Trig_Direction_Register::writeRTSI3_Pin_Dir(nTriggers::tTrig_RTSI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setRTSI3_Pin_Dir(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_RTSI_i_Pin_Dir_t tTriggers::tRTSI_Trig_Direction_Register::readRTSI3_Pin_Dir(nMDBG::tStatus2* s)
{
   return getRTSI3_Pin_Dir(s);
}

inline tTriggers::tRTSI_Trig_Direction_Register& tTriggers::tRTSI_Trig_Direction_Register::setRTSI4_Pin_Dir(nTriggers::tTrig_RTSI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xefff) | ((u16(fieldValue) << 0xc) & ~0xefff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_RTSI_i_Pin_Dir_t tTriggers::tRTSI_Trig_Direction_Register::getRTSI4_Pin_Dir(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_RTSI_i_Pin_Dir_t((_softCopy & ~0xefff) >> 0xc);
}

inline void tTriggers::tRTSI_Trig_Direction_Register::writeRTSI4_Pin_Dir(nTriggers::tTrig_RTSI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setRTSI4_Pin_Dir(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_RTSI_i_Pin_Dir_t tTriggers::tRTSI_Trig_Direction_Register::readRTSI4_Pin_Dir(nMDBG::tStatus2* s)
{
   return getRTSI4_Pin_Dir(s);
}

inline tTriggers::tRTSI_Trig_Direction_Register& tTriggers::tRTSI_Trig_Direction_Register::setRTSI5_Pin_Dir(nTriggers::tTrig_RTSI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xdfff) | ((u16(fieldValue) << 0xd) & ~0xdfff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_RTSI_i_Pin_Dir_t tTriggers::tRTSI_Trig_Direction_Register::getRTSI5_Pin_Dir(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_RTSI_i_Pin_Dir_t((_softCopy & ~0xdfff) >> 0xd);
}

inline void tTriggers::tRTSI_Trig_Direction_Register::writeRTSI5_Pin_Dir(nTriggers::tTrig_RTSI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setRTSI5_Pin_Dir(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_RTSI_i_Pin_Dir_t tTriggers::tRTSI_Trig_Direction_Register::readRTSI5_Pin_Dir(nMDBG::tStatus2* s)
{
   return getRTSI5_Pin_Dir(s);
}

inline tTriggers::tRTSI_Trig_Direction_Register& tTriggers::tRTSI_Trig_Direction_Register::setRTSI6_Pin_Dir(nTriggers::tTrig_RTSI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xbfff) | ((u16(fieldValue) << 0xe) & ~0xbfff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_RTSI_i_Pin_Dir_t tTriggers::tRTSI_Trig_Direction_Register::getRTSI6_Pin_Dir(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_RTSI_i_Pin_Dir_t((_softCopy & ~0xbfff) >> 0xe);
}

inline void tTriggers::tRTSI_Trig_Direction_Register::writeRTSI6_Pin_Dir(nTriggers::tTrig_RTSI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setRTSI6_Pin_Dir(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_RTSI_i_Pin_Dir_t tTriggers::tRTSI_Trig_Direction_Register::readRTSI6_Pin_Dir(nMDBG::tStatus2* s)
{
   return getRTSI6_Pin_Dir(s);
}

inline tTriggers::tRTSI_Trig_Direction_Register& tTriggers::tRTSI_Trig_Direction_Register::setRTSI7_Pin_Dir(nTriggers::tTrig_RTSI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0x7fff) | ((u16(fieldValue) << 0xf) & ~0x7fff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_RTSI_i_Pin_Dir_t tTriggers::tRTSI_Trig_Direction_Register::getRTSI7_Pin_Dir(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_RTSI_i_Pin_Dir_t((_softCopy & ~0x7fff) >> 0xf);
}

inline void tTriggers::tRTSI_Trig_Direction_Register::writeRTSI7_Pin_Dir(nTriggers::tTrig_RTSI_i_Pin_Dir_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setRTSI7_Pin_Dir(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_RTSI_i_Pin_Dir_t tTriggers::tRTSI_Trig_Direction_Register::readRTSI7_Pin_Dir(nMDBG::tStatus2* s)
{
   return getRTSI7_Pin_Dir(s);
}

inline tTriggers::tRTSI_OutputSelectRegister_t::tRTSI_OutputSelectRegister_t(u32 offset, u32 id)
 : kOffset(offset),
   kId(id)
{
   _softCopy = u8(0x0);
}

inline tTriggers::tRTSI_OutputSelectRegister_t::tRTSI_OutputSelectRegister_t()
 : kOffset((u32)~0),
   kId((u32)~0)
{
   _softCopy = u8(0x0);
}

inline void tTriggers::tRTSI_OutputSelectRegister_t::initialize(u32 offset, u32 id)
{
   u32* mutableOffset = const_cast<u32*>(&this->kOffset);
   u32* mutableId     = const_cast<u32*>(&this->kId);
   *mutableOffset = offset;
   *mutableId = id;
}

inline tTriggers::tRTSI_OutputSelectRegister_t::tRegisterMap* tTriggers::tRTSI_OutputSelectRegister_t::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tRTSI_OutputSelectRegister_t::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u8 tTriggers::tRTSI_OutputSelectRegister_t::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tTriggers::tRTSI_OutputSelectRegister_t::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 tTriggers::tRTSI_OutputSelectRegister_t::writeRegister(u8 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   force = force || (_softCopy != fieldValue);
   _softCopy = fieldValue;
   flush(s, force);
}

inline u8 tTriggers::tRTSI_OutputSelectRegister_t::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tTriggers::tRTSI_OutputSelectRegister_t& tTriggers::tRTSI_OutputSelectRegister_t::setRTSI_i_Output_Select(nTriggers::tTrig_RTSI_i_Output_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u8 newValue;   newValue = (_softCopy & 0x80) | ((u8(fieldValue) << 0x0) & ~0x80);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_RTSI_i_Output_Select_t tTriggers::tRTSI_OutputSelectRegister_t::getRTSI_i_Output_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_RTSI_i_Output_Select_t((_softCopy & ~0x80) >> 0x0);
}

inline void tTriggers::tRTSI_OutputSelectRegister_t::writeRTSI_i_Output_Select(nTriggers::tTrig_RTSI_i_Output_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setRTSI_i_Output_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_RTSI_i_Output_Select_t tTriggers::tRTSI_OutputSelectRegister_t::readRTSI_i_Output_Select(nMDBG::tStatus2* s)
{
   return getRTSI_i_Output_Select(s);
}

inline tTriggers::tPFI_Filter_Register_0::tPFI_Filter_Register_0()
{
   _softCopy = u16(0x0);
}

inline tTriggers::tPFI_Filter_Register_0::tRegisterMap* tTriggers::tPFI_Filter_Register_0::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tPFI_Filter_Register_0::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tTriggers::tPFI_Filter_Register_0::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tTriggers::tPFI_Filter_Register_0::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 &= u16(0xffff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tTriggers::tPFI_Filter_Register_0::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tTriggers::tPFI_Filter_Register_0& tTriggers::tPFI_Filter_Register_0::setPFI0_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfff8) | ((u16(fieldValue) << 0x0) & ~0xfff8);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_0::getPFI0_Filter_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Select_t((_softCopy & ~0xfff8) >> 0x0);
}

inline void tTriggers::tPFI_Filter_Register_0::writePFI0_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI0_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_0::readPFI0_Filter_Select(nMDBG::tStatus2* s)
{
   return getPFI0_Filter_Select(s);
}

inline tTriggers::tPFI_Filter_Register_0& tTriggers::tPFI_Filter_Register_0::setPFI1_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xff8f) | ((u16(fieldValue) << 0x4) & ~0xff8f);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_0::getPFI1_Filter_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Select_t((_softCopy & ~0xff8f) >> 0x4);
}

inline void tTriggers::tPFI_Filter_Register_0::writePFI1_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI1_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_0::readPFI1_Filter_Select(nMDBG::tStatus2* s)
{
   return getPFI1_Filter_Select(s);
}

inline tTriggers::tPFI_Filter_Register_0& tTriggers::tPFI_Filter_Register_0::setPFI2_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xf8ff) | ((u16(fieldValue) << 0x8) & ~0xf8ff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_0::getPFI2_Filter_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Select_t((_softCopy & ~0xf8ff) >> 0x8);
}

inline void tTriggers::tPFI_Filter_Register_0::writePFI2_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI2_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_0::readPFI2_Filter_Select(nMDBG::tStatus2* s)
{
   return getPFI2_Filter_Select(s);
}

inline tTriggers::tPFI_Filter_Register_0& tTriggers::tPFI_Filter_Register_0::setPFI3_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0x8fff) | ((u16(fieldValue) << 0xc) & ~0x8fff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_0::getPFI3_Filter_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Select_t((_softCopy & ~0x8fff) >> 0xc);
}

inline void tTriggers::tPFI_Filter_Register_0::writePFI3_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI3_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_0::readPFI3_Filter_Select(nMDBG::tStatus2* s)
{
   return getPFI3_Filter_Select(s);
}

inline tTriggers::tPFI_Filter_Register_1::tPFI_Filter_Register_1()
{
   _softCopy = u16(0x0);
}

inline tTriggers::tPFI_Filter_Register_1::tRegisterMap* tTriggers::tPFI_Filter_Register_1::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tPFI_Filter_Register_1::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tTriggers::tPFI_Filter_Register_1::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tTriggers::tPFI_Filter_Register_1::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 &= u16(0xffff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tTriggers::tPFI_Filter_Register_1::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tTriggers::tPFI_Filter_Register_1& tTriggers::tPFI_Filter_Register_1::setPFI4_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfff8) | ((u16(fieldValue) << 0x0) & ~0xfff8);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_1::getPFI4_Filter_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Select_t((_softCopy & ~0xfff8) >> 0x0);
}

inline void tTriggers::tPFI_Filter_Register_1::writePFI4_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI4_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_1::readPFI4_Filter_Select(nMDBG::tStatus2* s)
{
   return getPFI4_Filter_Select(s);
}

inline tTriggers::tPFI_Filter_Register_1& tTriggers::tPFI_Filter_Register_1::setPFI5_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xff8f) | ((u16(fieldValue) << 0x4) & ~0xff8f);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_1::getPFI5_Filter_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Select_t((_softCopy & ~0xff8f) >> 0x4);
}

inline void tTriggers::tPFI_Filter_Register_1::writePFI5_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI5_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_1::readPFI5_Filter_Select(nMDBG::tStatus2* s)
{
   return getPFI5_Filter_Select(s);
}

inline tTriggers::tPFI_Filter_Register_1& tTriggers::tPFI_Filter_Register_1::setPFI6_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xf8ff) | ((u16(fieldValue) << 0x8) & ~0xf8ff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_1::getPFI6_Filter_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Select_t((_softCopy & ~0xf8ff) >> 0x8);
}

inline void tTriggers::tPFI_Filter_Register_1::writePFI6_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI6_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_1::readPFI6_Filter_Select(nMDBG::tStatus2* s)
{
   return getPFI6_Filter_Select(s);
}

inline tTriggers::tPFI_Filter_Register_1& tTriggers::tPFI_Filter_Register_1::setPFI7_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0x8fff) | ((u16(fieldValue) << 0xc) & ~0x8fff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_1::getPFI7_Filter_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Select_t((_softCopy & ~0x8fff) >> 0xc);
}

inline void tTriggers::tPFI_Filter_Register_1::writePFI7_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI7_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_1::readPFI7_Filter_Select(nMDBG::tStatus2* s)
{
   return getPFI7_Filter_Select(s);
}

inline tTriggers::tPFI_Filter_Register_2::tPFI_Filter_Register_2()
{
   _softCopy = u16(0x0);
}

inline tTriggers::tPFI_Filter_Register_2::tRegisterMap* tTriggers::tPFI_Filter_Register_2::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tPFI_Filter_Register_2::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tTriggers::tPFI_Filter_Register_2::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tTriggers::tPFI_Filter_Register_2::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 &= u16(0xffff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tTriggers::tPFI_Filter_Register_2::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tTriggers::tPFI_Filter_Register_2& tTriggers::tPFI_Filter_Register_2::setPFI8_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfff8) | ((u16(fieldValue) << 0x0) & ~0xfff8);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_2::getPFI8_Filter_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Select_t((_softCopy & ~0xfff8) >> 0x0);
}

inline void tTriggers::tPFI_Filter_Register_2::writePFI8_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI8_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_2::readPFI8_Filter_Select(nMDBG::tStatus2* s)
{
   return getPFI8_Filter_Select(s);
}

inline tTriggers::tPFI_Filter_Register_2& tTriggers::tPFI_Filter_Register_2::setPFI9_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xff8f) | ((u16(fieldValue) << 0x4) & ~0xff8f);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_2::getPFI9_Filter_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Select_t((_softCopy & ~0xff8f) >> 0x4);
}

inline void tTriggers::tPFI_Filter_Register_2::writePFI9_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI9_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_2::readPFI9_Filter_Select(nMDBG::tStatus2* s)
{
   return getPFI9_Filter_Select(s);
}

inline tTriggers::tPFI_Filter_Register_2& tTriggers::tPFI_Filter_Register_2::setPFI10_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xf8ff) | ((u16(fieldValue) << 0x8) & ~0xf8ff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_2::getPFI10_Filter_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Select_t((_softCopy & ~0xf8ff) >> 0x8);
}

inline void tTriggers::tPFI_Filter_Register_2::writePFI10_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI10_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_2::readPFI10_Filter_Select(nMDBG::tStatus2* s)
{
   return getPFI10_Filter_Select(s);
}

inline tTriggers::tPFI_Filter_Register_2& tTriggers::tPFI_Filter_Register_2::setPFI11_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0x8fff) | ((u16(fieldValue) << 0xc) & ~0x8fff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_2::getPFI11_Filter_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Select_t((_softCopy & ~0x8fff) >> 0xc);
}

inline void tTriggers::tPFI_Filter_Register_2::writePFI11_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI11_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_2::readPFI11_Filter_Select(nMDBG::tStatus2* s)
{
   return getPFI11_Filter_Select(s);
}

inline tTriggers::tPFI_Filter_Register_3::tPFI_Filter_Register_3()
{
   _softCopy = u16(0x0);
}

inline tTriggers::tPFI_Filter_Register_3::tRegisterMap* tTriggers::tPFI_Filter_Register_3::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tPFI_Filter_Register_3::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tTriggers::tPFI_Filter_Register_3::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tTriggers::tPFI_Filter_Register_3::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 &= u16(0xffff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tTriggers::tPFI_Filter_Register_3::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tTriggers::tPFI_Filter_Register_3& tTriggers::tPFI_Filter_Register_3::setPFI12_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfff8) | ((u16(fieldValue) << 0x0) & ~0xfff8);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_3::getPFI12_Filter_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Select_t((_softCopy & ~0xfff8) >> 0x0);
}

inline void tTriggers::tPFI_Filter_Register_3::writePFI12_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI12_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_3::readPFI12_Filter_Select(nMDBG::tStatus2* s)
{
   return getPFI12_Filter_Select(s);
}

inline tTriggers::tPFI_Filter_Register_3& tTriggers::tPFI_Filter_Register_3::setPFI13_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xff8f) | ((u16(fieldValue) << 0x4) & ~0xff8f);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_3::getPFI13_Filter_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Select_t((_softCopy & ~0xff8f) >> 0x4);
}

inline void tTriggers::tPFI_Filter_Register_3::writePFI13_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI13_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_3::readPFI13_Filter_Select(nMDBG::tStatus2* s)
{
   return getPFI13_Filter_Select(s);
}

inline tTriggers::tPFI_Filter_Register_3& tTriggers::tPFI_Filter_Register_3::setPFI14_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xf8ff) | ((u16(fieldValue) << 0x8) & ~0xf8ff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_3::getPFI14_Filter_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Select_t((_softCopy & ~0xf8ff) >> 0x8);
}

inline void tTriggers::tPFI_Filter_Register_3::writePFI14_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI14_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_3::readPFI14_Filter_Select(nMDBG::tStatus2* s)
{
   return getPFI14_Filter_Select(s);
}

inline tTriggers::tPFI_Filter_Register_3& tTriggers::tPFI_Filter_Register_3::setPFI15_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0x8fff) | ((u16(fieldValue) << 0xc) & ~0x8fff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_3::getPFI15_Filter_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Select_t((_softCopy & ~0x8fff) >> 0xc);
}

inline void tTriggers::tPFI_Filter_Register_3::writePFI15_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI15_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Select_t tTriggers::tPFI_Filter_Register_3::readPFI15_Filter_Select(nMDBG::tStatus2* s)
{
   return getPFI15_Filter_Select(s);
}

inline tTriggers::tSTAR_Trig_Register::tSTAR_Trig_Register()
{
   _softCopy = u16(0x0);
}

inline tTriggers::tSTAR_Trig_Register::tRegisterMap* tTriggers::tSTAR_Trig_Register::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tSTAR_Trig_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tTriggers::tSTAR_Trig_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tTriggers::tSTAR_Trig_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 &= u16(0xffff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tTriggers::tSTAR_Trig_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tTriggers::tSTAR_Trig_Register& tTriggers::tSTAR_Trig_Register::setStar_Trig_Output_Select(nTriggers::tTrig_StarTrig_Output_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfff0) | ((u16(fieldValue) << 0x0) & ~0xfff0);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_StarTrig_Output_Select_t tTriggers::tSTAR_Trig_Register::getStar_Trig_Output_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_StarTrig_Output_Select_t((_softCopy & ~0xfff0) >> 0x0);
}

inline void tTriggers::tSTAR_Trig_Register::writeStar_Trig_Output_Select(nTriggers::tTrig_StarTrig_Output_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setStar_Trig_Output_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_StarTrig_Output_Select_t tTriggers::tSTAR_Trig_Register::readStar_Trig_Output_Select(nMDBG::tStatus2* s)
{
   return getStar_Trig_Output_Select(s);
}

inline tTriggers::tSTAR_Trig_Register& tTriggers::tSTAR_Trig_Register::setStar_Trig_Pin_Dir(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0x7fff) | ((u16(fieldValue) << 0xf) & ~0x7fff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tTriggers::tSTAR_Trig_Register::getStar_Trig_Pin_Dir(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0x7fff) >> 0xf);
}

inline void tTriggers::tSTAR_Trig_Register::writeStar_Trig_Pin_Dir(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setStar_Trig_Pin_Dir(fieldValue, s);
   flush(s, force);
}
inline u16 tTriggers::tSTAR_Trig_Register::readStar_Trig_Pin_Dir(nMDBG::tStatus2* s)
{
   return getStar_Trig_Pin_Dir(s);
}

inline tTriggers::tPFI_OutputSelectRegister_t::tPFI_OutputSelectRegister_t(u32 offset, u32 id)
 : kOffset(offset),
   kId(id)
{
   _softCopy = u8(0x0);
}

inline tTriggers::tPFI_OutputSelectRegister_t::tPFI_OutputSelectRegister_t()
 : kOffset((u32)~0),
   kId((u32)~0)
{
   _softCopy = u8(0x0);
}

inline void tTriggers::tPFI_OutputSelectRegister_t::initialize(u32 offset, u32 id)
{
   u32* mutableOffset = const_cast<u32*>(&this->kOffset);
   u32* mutableId     = const_cast<u32*>(&this->kId);
   *mutableOffset = offset;
   *mutableId = id;
}

inline tTriggers::tPFI_OutputSelectRegister_t::tRegisterMap* tTriggers::tPFI_OutputSelectRegister_t::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tPFI_OutputSelectRegister_t::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u8 tTriggers::tPFI_OutputSelectRegister_t::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tTriggers::tPFI_OutputSelectRegister_t::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 tTriggers::tPFI_OutputSelectRegister_t::writeRegister(u8 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   force = force || (_softCopy != fieldValue);
   _softCopy = fieldValue;
   flush(s, force);
}

inline u8 tTriggers::tPFI_OutputSelectRegister_t::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tTriggers::tPFI_OutputSelectRegister_t& tTriggers::tPFI_OutputSelectRegister_t::setPFI_i_Output_Select(nTriggers::tTrig_PFI_Output_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u8 newValue;   newValue = (_softCopy & 0x80) | ((u8(fieldValue) << 0x0) & ~0x80);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_PFI_Output_Select_t tTriggers::tPFI_OutputSelectRegister_t::getPFI_i_Output_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_PFI_Output_Select_t((_softCopy & ~0x80) >> 0x0);
}

inline void tTriggers::tPFI_OutputSelectRegister_t::writePFI_i_Output_Select(nTriggers::tTrig_PFI_Output_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI_i_Output_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_PFI_Output_Select_t tTriggers::tPFI_OutputSelectRegister_t::readPFI_i_Output_Select(nMDBG::tStatus2* s)
{
   return getPFI_i_Output_Select(s);
}

inline tTriggers::tDStarC_Trig_Register::tDStarC_Trig_Register()
{
   _softCopy = u16(0x0);
}

inline tTriggers::tDStarC_Trig_Register::tRegisterMap* tTriggers::tDStarC_Trig_Register::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tDStarC_Trig_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tTriggers::tDStarC_Trig_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tTriggers::tDStarC_Trig_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 &= u16(0xffff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tTriggers::tDStarC_Trig_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tTriggers::tDStarC_Trig_Register& tTriggers::tDStarC_Trig_Register::setDStarC_Output_Select(nTriggers::tTrig_StarTrig_Output_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfff0) | ((u16(fieldValue) << 0x0) & ~0xfff0);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_StarTrig_Output_Select_t tTriggers::tDStarC_Trig_Register::getDStarC_Output_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_StarTrig_Output_Select_t((_softCopy & ~0xfff0) >> 0x0);
}

inline void tTriggers::tDStarC_Trig_Register::writeDStarC_Output_Select(nTriggers::tTrig_StarTrig_Output_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDStarC_Output_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_StarTrig_Output_Select_t tTriggers::tDStarC_Trig_Register::readDStarC_Output_Select(nMDBG::tStatus2* s)
{
   return getDStarC_Output_Select(s);
}

inline tTriggers::tDStarC_Trig_Register& tTriggers::tDStarC_Trig_Register::setDStarC_Enable(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0x7fff) | ((u16(fieldValue) << 0xf) & ~0x7fff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tTriggers::tDStarC_Trig_Register::getDStarC_Enable(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0x7fff) >> 0xf);
}

inline void tTriggers::tDStarC_Trig_Register::writeDStarC_Enable(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setDStarC_Enable(fieldValue, s);
   flush(s, force);
}
inline u16 tTriggers::tDStarC_Trig_Register::readDStarC_Enable(nMDBG::tStatus2* s)
{
   return getDStarC_Enable(s);
}

inline tTriggers::tClock_And_Fout2_Register::tClock_And_Fout2_Register()
{
   _softCopy = u16(0x0);
}

inline tTriggers::tClock_And_Fout2_Register::tRegisterMap* tTriggers::tClock_And_Fout2_Register::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tClock_And_Fout2_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tTriggers::tClock_And_Fout2_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tTriggers::tClock_And_Fout2_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 &= u16(0xffff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tTriggers::tClock_And_Fout2_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tTriggers::tClock_And_Fout2_Register& tTriggers::tClock_And_Fout2_Register::setPLL_In_Source_Select(nTriggers::tTrig_PLL_In_Source_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xffe0) | ((u16(fieldValue) << 0x0) & ~0xffe0);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_PLL_In_Source_Select_t tTriggers::tClock_And_Fout2_Register::getPLL_In_Source_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_PLL_In_Source_Select_t((_softCopy & ~0xffe0) >> 0x0);
}

inline void tTriggers::tClock_And_Fout2_Register::writePLL_In_Source_Select(nTriggers::tTrig_PLL_In_Source_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPLL_In_Source_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_PLL_In_Source_Select_t tTriggers::tClock_And_Fout2_Register::readPLL_In_Source_Select(nMDBG::tStatus2* s)
{
   return getPLL_In_Source_Select(s);
}

inline tTriggers::tClock_And_Fout2_Register& tTriggers::tClock_And_Fout2_Register::setTB3_Select(nTriggers::tTrig_TB3_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xffbf) | ((u16(fieldValue) << 0x6) & ~0xffbf);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_TB3_Select_t tTriggers::tClock_And_Fout2_Register::getTB3_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_TB3_Select_t((_softCopy & ~0xffbf) >> 0x6);
}

inline void tTriggers::tClock_And_Fout2_Register::writeTB3_Select(nTriggers::tTrig_TB3_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setTB3_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_TB3_Select_t tTriggers::tClock_And_Fout2_Register::readTB3_Select(nMDBG::tStatus2* s)
{
   return getTB3_Select(s);
}

inline tTriggers::tPLL_Control_Register::tPLL_Control_Register()
{
   _softCopy = u32(0x0);
}

inline tTriggers::tPLL_Control_Register::tRegisterMap* tTriggers::tPLL_Control_Register::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tPLL_Control_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u32 tTriggers::tPLL_Control_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tTriggers::tPLL_Control_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 tTriggers::tPLL_Control_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 tTriggers::tPLL_Control_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tTriggers::tPLL_Control_Register& tTriggers::tPLL_Control_Register::setPLL_OutputDivider(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffc0ff) | ((u32(fieldValue) << 0x8) & ~0xffffc0ff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tTriggers::tPLL_Control_Register::getPLL_OutputDivider(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xffffc0ff) >> 0x8);
}

inline void tTriggers::tPLL_Control_Register::writePLL_OutputDivider(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPLL_OutputDivider(fieldValue, s);
   flush(s, force);
}
inline u32 tTriggers::tPLL_Control_Register::readPLL_OutputDivider(nMDBG::tStatus2* s)
{
   return getPLL_OutputDivider(s);
}

inline tTriggers::tPLL_Control_Register& tTriggers::tPLL_Control_Register::setPLL_Multiplier(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffe03fff) | ((u32(fieldValue) << 0xe) & ~0xffe03fff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tTriggers::tPLL_Control_Register::getPLL_Multiplier(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xffe03fff) >> 0xe);
}

inline void tTriggers::tPLL_Control_Register::writePLL_Multiplier(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPLL_Multiplier(fieldValue, s);
   flush(s, force);
}
inline u32 tTriggers::tPLL_Control_Register::readPLL_Multiplier(nMDBG::tStatus2* s)
{
   return getPLL_Multiplier(s);
}

inline tTriggers::tPLL_Control_Register& tTriggers::tPLL_Control_Register::setPLL_RefDivisor(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xf01fffff) | ((u32(fieldValue) << 0x15) & ~0xf01fffff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tTriggers::tPLL_Control_Register::getPLL_RefDivisor(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xf01fffff) >> 0x15);
}

inline void tTriggers::tPLL_Control_Register::writePLL_RefDivisor(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPLL_RefDivisor(fieldValue, s);
   flush(s, force);
}
inline u32 tTriggers::tPLL_Control_Register::readPLL_RefDivisor(nMDBG::tStatus2* s)
{
   return getPLL_RefDivisor(s);
}

inline tTriggers::tPLL_Control_Register& tTriggers::tPLL_Control_Register::setPLL_Filter_Range(nTriggers::tTrig_PLL_Filter_Range_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0x8fffffff) | ((u32(fieldValue) << 0x1c) & ~0x8fffffff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_PLL_Filter_Range_t tTriggers::tPLL_Control_Register::getPLL_Filter_Range(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_PLL_Filter_Range_t((_softCopy & ~0x8fffffff) >> 0x1c);
}

inline void tTriggers::tPLL_Control_Register::writePLL_Filter_Range(nTriggers::tTrig_PLL_Filter_Range_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPLL_Filter_Range(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_PLL_Filter_Range_t tTriggers::tPLL_Control_Register::readPLL_Filter_Range(nMDBG::tStatus2* s)
{
   return getPLL_Filter_Range(s);
}

inline tTriggers::tPLL_Control_Register& tTriggers::tPLL_Control_Register::setPLL_Enable(u32 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 u32 tTriggers::tPLL_Control_Register::getPLL_Enable(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x7fffffff) >> 0x1f);
}

inline void tTriggers::tPLL_Control_Register::writePLL_Enable(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPLL_Enable(fieldValue, s);
   flush(s, force);
}
inline u32 tTriggers::tPLL_Control_Register::readPLL_Enable(nMDBG::tStatus2* s)
{
   return getPLL_Enable(s);
}

inline tTriggers::tPLL_Status_Register::tPLL_Status_Register()
{
   _softCopy = u16(0x0);
}

inline tTriggers::tPLL_Status_Register::tRegisterMap* tTriggers::tPLL_Status_Register::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tPLL_Status_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tTriggers::tPLL_Status_Register& tTriggers::tPLL_Status_Register::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   _softCopy = fieldValue;
   return *this;
}

inline u16 tTriggers::tPLL_Status_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

inline u16 tTriggers::tPLL_Status_Register::readRegister(nMDBG::tStatus2* s)
{
   refresh(s);
   return _softCopy;
}

inline tTriggers::tPLL_Status_Register& tTriggers::tPLL_Status_Register::setPLL_TimerExpired(nTriggers::tTrigPllLockedStatus_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfffe) | ((u16(fieldValue) << 0x0) & ~0xfffe);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrigPllLockedStatus_t tTriggers::tPLL_Status_Register::getPLL_TimerExpired(nMDBG::tStatus2*) const
{
   return nTriggers::tTrigPllLockedStatus_t((_softCopy & ~0xfffe) >> 0x0);
}

inline nTriggers::tTrigPllLockedStatus_t tTriggers::tPLL_Status_Register::readPLL_TimerExpired(nMDBG::tStatus2* s)
{
   refresh(s);
   return getPLL_TimerExpired(s);
}

inline tTriggers::tPLL_Status_Register& tTriggers::tPLL_Status_Register::setHW_Pll_Locked(nTriggers::tTrigPllLockedStatus_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfffd) | ((u16(fieldValue) << 0x1) & ~0xfffd);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrigPllLockedStatus_t tTriggers::tPLL_Status_Register::getHW_Pll_Locked(nMDBG::tStatus2*) const
{
   return nTriggers::tTrigPllLockedStatus_t((_softCopy & ~0xfffd) >> 0x1);
}

inline nTriggers::tTrigPllLockedStatus_t tTriggers::tPLL_Status_Register::readHW_Pll_Locked(nMDBG::tStatus2* s)
{
   refresh(s);
   return getHW_Pll_Locked(s);
}

inline tTriggers::tPFI_DI_Register::tPFI_DI_Register()
{
   _softCopy = u16(0x0);
}

inline tTriggers::tPFI_DI_Register::tRegisterMap* tTriggers::tPFI_DI_Register::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tPFI_DI_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

inline tTriggers::tPFI_DI_Register& tTriggers::tPFI_DI_Register::setRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   _softCopy = fieldValue;
   return *this;
}

inline u16 tTriggers::tPFI_DI_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

inline u16 tTriggers::tPFI_DI_Register::readRegister(nMDBG::tStatus2* s)
{
   refresh(s);
   return _softCopy;
}

inline tTriggers::tPFI_DI_Register& tTriggers::tPFI_DI_Register::setPFI_0_DI_Bitfield(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfffe) | ((u16(fieldValue) << 0x0) & ~0xfffe);
   setRegister(newValue, s);
   return *this;
}

inline u16 tTriggers::tPFI_DI_Register::getPFI_0_DI_Bitfield(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfffe) >> 0x0);
}

inline u16 tTriggers::tPFI_DI_Register::readPFI_0_DI_Bitfield(nMDBG::tStatus2* s)
{
   refresh(s);
   return getPFI_0_DI_Bitfield(s);
}

inline tTriggers::tPFI_DI_Register& tTriggers::tPFI_DI_Register::setPFI_1_DI_Bitfield(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfffd) | ((u16(fieldValue) << 0x1) & ~0xfffd);
   setRegister(newValue, s);
   return *this;
}

inline u16 tTriggers::tPFI_DI_Register::getPFI_1_DI_Bitfield(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfffd) >> 0x1);
}

inline u16 tTriggers::tPFI_DI_Register::readPFI_1_DI_Bitfield(nMDBG::tStatus2* s)
{
   refresh(s);
   return getPFI_1_DI_Bitfield(s);
}

inline tTriggers::tPFI_DI_Register& tTriggers::tPFI_DI_Register::setPFI_2_DI_Bitfield(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfffb) | ((u16(fieldValue) << 0x2) & ~0xfffb);
   setRegister(newValue, s);
   return *this;
}

inline u16 tTriggers::tPFI_DI_Register::getPFI_2_DI_Bitfield(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfffb) >> 0x2);
}

inline u16 tTriggers::tPFI_DI_Register::readPFI_2_DI_Bitfield(nMDBG::tStatus2* s)
{
   refresh(s);
   return getPFI_2_DI_Bitfield(s);
}

inline tTriggers::tPFI_DI_Register& tTriggers::tPFI_DI_Register::setPFI_3_DI_Bitfield(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfff7) | ((u16(fieldValue) << 0x3) & ~0xfff7);
   setRegister(newValue, s);
   return *this;
}

inline u16 tTriggers::tPFI_DI_Register::getPFI_3_DI_Bitfield(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfff7) >> 0x3);
}

inline u16 tTriggers::tPFI_DI_Register::readPFI_3_DI_Bitfield(nMDBG::tStatus2* s)
{
   refresh(s);
   return getPFI_3_DI_Bitfield(s);
}

inline tTriggers::tPFI_DI_Register& tTriggers::tPFI_DI_Register::setPFI_4_DI_Bitfield(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xffef) | ((u16(fieldValue) << 0x4) & ~0xffef);
   setRegister(newValue, s);
   return *this;
}

inline u16 tTriggers::tPFI_DI_Register::getPFI_4_DI_Bitfield(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xffef) >> 0x4);
}

inline u16 tTriggers::tPFI_DI_Register::readPFI_4_DI_Bitfield(nMDBG::tStatus2* s)
{
   refresh(s);
   return getPFI_4_DI_Bitfield(s);
}

inline tTriggers::tPFI_DI_Register& tTriggers::tPFI_DI_Register::setPFI_5_DI_Bitfield(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xffdf) | ((u16(fieldValue) << 0x5) & ~0xffdf);
   setRegister(newValue, s);
   return *this;
}

inline u16 tTriggers::tPFI_DI_Register::getPFI_5_DI_Bitfield(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xffdf) >> 0x5);
}

inline u16 tTriggers::tPFI_DI_Register::readPFI_5_DI_Bitfield(nMDBG::tStatus2* s)
{
   refresh(s);
   return getPFI_5_DI_Bitfield(s);
}

inline tTriggers::tPFI_DI_Register& tTriggers::tPFI_DI_Register::setPFI_6_DI_Bitfield(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xffbf) | ((u16(fieldValue) << 0x6) & ~0xffbf);
   setRegister(newValue, s);
   return *this;
}

inline u16 tTriggers::tPFI_DI_Register::getPFI_6_DI_Bitfield(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xffbf) >> 0x6);
}

inline u16 tTriggers::tPFI_DI_Register::readPFI_6_DI_Bitfield(nMDBG::tStatus2* s)
{
   refresh(s);
   return getPFI_6_DI_Bitfield(s);
}

inline tTriggers::tPFI_DI_Register& tTriggers::tPFI_DI_Register::setPFI_7_DI_Bitfield(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xff7f) | ((u16(fieldValue) << 0x7) & ~0xff7f);
   setRegister(newValue, s);
   return *this;
}

inline u16 tTriggers::tPFI_DI_Register::getPFI_7_DI_Bitfield(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xff7f) >> 0x7);
}

inline u16 tTriggers::tPFI_DI_Register::readPFI_7_DI_Bitfield(nMDBG::tStatus2* s)
{
   refresh(s);
   return getPFI_7_DI_Bitfield(s);
}

inline tTriggers::tPFI_DI_Register& tTriggers::tPFI_DI_Register::setPFI_8_DI_Bitfield(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfeff) | ((u16(fieldValue) << 0x8) & ~0xfeff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tTriggers::tPFI_DI_Register::getPFI_8_DI_Bitfield(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfeff) >> 0x8);
}

inline u16 tTriggers::tPFI_DI_Register::readPFI_8_DI_Bitfield(nMDBG::tStatus2* s)
{
   refresh(s);
   return getPFI_8_DI_Bitfield(s);
}

inline tTriggers::tPFI_DI_Register& tTriggers::tPFI_DI_Register::setPFI_9_DI_Bitfield(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfdff) | ((u16(fieldValue) << 0x9) & ~0xfdff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tTriggers::tPFI_DI_Register::getPFI_9_DI_Bitfield(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfdff) >> 0x9);
}

inline u16 tTriggers::tPFI_DI_Register::readPFI_9_DI_Bitfield(nMDBG::tStatus2* s)
{
   refresh(s);
   return getPFI_9_DI_Bitfield(s);
}

inline tTriggers::tPFI_DI_Register& tTriggers::tPFI_DI_Register::setPFI_10_DI_Bitfield(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfbff) | ((u16(fieldValue) << 0xa) & ~0xfbff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tTriggers::tPFI_DI_Register::getPFI_10_DI_Bitfield(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfbff) >> 0xa);
}

inline u16 tTriggers::tPFI_DI_Register::readPFI_10_DI_Bitfield(nMDBG::tStatus2* s)
{
   refresh(s);
   return getPFI_10_DI_Bitfield(s);
}

inline tTriggers::tPFI_DI_Register& tTriggers::tPFI_DI_Register::setPFI_11_DI_Bitfield(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xf7ff) | ((u16(fieldValue) << 0xb) & ~0xf7ff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tTriggers::tPFI_DI_Register::getPFI_11_DI_Bitfield(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xf7ff) >> 0xb);
}

inline u16 tTriggers::tPFI_DI_Register::readPFI_11_DI_Bitfield(nMDBG::tStatus2* s)
{
   refresh(s);
   return getPFI_11_DI_Bitfield(s);
}

inline tTriggers::tPFI_DI_Register& tTriggers::tPFI_DI_Register::setPFI_12_DI_Bitfield(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xefff) | ((u16(fieldValue) << 0xc) & ~0xefff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tTriggers::tPFI_DI_Register::getPFI_12_DI_Bitfield(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xefff) >> 0xc);
}

inline u16 tTriggers::tPFI_DI_Register::readPFI_12_DI_Bitfield(nMDBG::tStatus2* s)
{
   refresh(s);
   return getPFI_12_DI_Bitfield(s);
}

inline tTriggers::tPFI_DI_Register& tTriggers::tPFI_DI_Register::setPFI_13_DI_Bitfield(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xdfff) | ((u16(fieldValue) << 0xd) & ~0xdfff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tTriggers::tPFI_DI_Register::getPFI_13_DI_Bitfield(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xdfff) >> 0xd);
}

inline u16 tTriggers::tPFI_DI_Register::readPFI_13_DI_Bitfield(nMDBG::tStatus2* s)
{
   refresh(s);
   return getPFI_13_DI_Bitfield(s);
}

inline tTriggers::tPFI_DI_Register& tTriggers::tPFI_DI_Register::setPFI_14_DI_Bitfield(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xbfff) | ((u16(fieldValue) << 0xe) & ~0xbfff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tTriggers::tPFI_DI_Register::getPFI_14_DI_Bitfield(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xbfff) >> 0xe);
}

inline u16 tTriggers::tPFI_DI_Register::readPFI_14_DI_Bitfield(nMDBG::tStatus2* s)
{
   refresh(s);
   return getPFI_14_DI_Bitfield(s);
}

inline tTriggers::tPFI_DI_Register& tTriggers::tPFI_DI_Register::setPFI_15_DI_Bitfield(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0x7fff) | ((u16(fieldValue) << 0xf) & ~0x7fff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tTriggers::tPFI_DI_Register::getPFI_15_DI_Bitfield(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0x7fff) >> 0xf);
}

inline u16 tTriggers::tPFI_DI_Register::readPFI_15_DI_Bitfield(nMDBG::tStatus2* s)
{
   refresh(s);
   return getPFI_15_DI_Bitfield(s);
}

inline tTriggers::tPFI_DO_Register::tPFI_DO_Register()
{
   _softCopy = u16(0x0);
}

inline tTriggers::tPFI_DO_Register::tRegisterMap* tTriggers::tPFI_DO_Register::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tPFI_DO_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tTriggers::tPFI_DO_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tTriggers::tPFI_DO_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 &= u16(0xffff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tTriggers::tPFI_DO_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tTriggers::tPFI_DO_Register& tTriggers::tPFI_DO_Register::setPFI_DO_Bf(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0x0) | ((u16(fieldValue) << 0x0) & ~0x0);
   setRegister(newValue, s);
   return *this;
}

inline u16 tTriggers::tPFI_DO_Register::getPFI_DO_Bf(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0x0) >> 0x0);
}

inline void tTriggers::tPFI_DO_Register::writePFI_DO_Bf(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI_DO_Bf(fieldValue, s);
   flush(s, force);
}
inline u16 tTriggers::tPFI_DO_Register::readPFI_DO_Bf(nMDBG::tStatus2* s)
{
   return getPFI_DO_Bf(s);
}

inline tTriggers::tPFI_WDT_SafeStateRegister::tPFI_WDT_SafeStateRegister()
{
   _softCopy = u16(0x0);
}

inline tTriggers::tPFI_WDT_SafeStateRegister::tRegisterMap* tTriggers::tPFI_WDT_SafeStateRegister::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tPFI_WDT_SafeStateRegister::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tTriggers::tPFI_WDT_SafeStateRegister::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tTriggers::tPFI_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 &= u16(0xffff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tTriggers::tPFI_WDT_SafeStateRegister::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tTriggers::tPFI_WDT_SafeStateRegister& tTriggers::tPFI_WDT_SafeStateRegister::setPFI_WDT_SafeStateValue(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0x0) | ((u16(fieldValue) << 0x0) & ~0x0);
   setRegister(newValue, s);
   return *this;
}

inline u16 tTriggers::tPFI_WDT_SafeStateRegister::getPFI_WDT_SafeStateValue(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0x0) >> 0x0);
}

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

inline tBoolean tTriggers::tPFI_WDT_SafeStateRegister::getPFI_WDT_SafeStateValue(u32 position, nMDBG::tStatus2*) const
{
   return (_softCopy >> (0x0 + position)) & 0x1;
}

inline void tTriggers::tPFI_WDT_SafeStateRegister::writePFI_WDT_SafeStateValue(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI_WDT_SafeStateValue(fieldValue, s);
   flush(s, force);
}
inline void tTriggers::tPFI_WDT_SafeStateRegister::writePFI_WDT_SafeStateValue(u32 position, tBoolean bitValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI_WDT_SafeStateValue(position, bitValue, s);
   flush(s, force);
}
inline u16 tTriggers::tPFI_WDT_SafeStateRegister::readPFI_WDT_SafeStateValue(nMDBG::tStatus2* s)
{
   return getPFI_WDT_SafeStateValue(s);
}

inline tBoolean tTriggers::tPFI_WDT_SafeStateRegister::readPFI_WDT_SafeStateValue(u32 position, nMDBG::tStatus2* s)
{
   return getPFI_WDT_SafeStateValue(position, s);
}

inline tTriggers::tPFI_WDT_ModeSelect_Register::tPFI_WDT_ModeSelect_Register()
{
   _softCopy = u32(0x0);
}

inline tTriggers::tPFI_WDT_ModeSelect_Register::tRegisterMap* tTriggers::tPFI_WDT_ModeSelect_Register::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tPFI_WDT_ModeSelect_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u32 tTriggers::tPFI_WDT_ModeSelect_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tTriggers::tPFI_WDT_ModeSelect_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 tTriggers::tPFI_WDT_ModeSelect_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 tTriggers::tPFI_WDT_ModeSelect_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tTriggers::tPFI_WDT_ModeSelect_Register& tTriggers::tPFI_WDT_ModeSelect_Register::setPFI_WDT_ModeD0(nTriggers::tPFI_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 nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::getPFI_WDT_ModeD0(nMDBG::tStatus2*) const
{
   return nTriggers::tPFI_WDT_Mode_t((_softCopy & ~0xfffffffc) >> 0x0);
}

inline void tTriggers::tPFI_WDT_ModeSelect_Register::writePFI_WDT_ModeD0(nTriggers::tPFI_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI_WDT_ModeD0(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::readPFI_WDT_ModeD0(nMDBG::tStatus2* s)
{
   return getPFI_WDT_ModeD0(s);
}

inline tTriggers::tPFI_WDT_ModeSelect_Register& tTriggers::tPFI_WDT_ModeSelect_Register::setPFI_WDT_ModeD1(nTriggers::tPFI_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 nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::getPFI_WDT_ModeD1(nMDBG::tStatus2*) const
{
   return nTriggers::tPFI_WDT_Mode_t((_softCopy & ~0xfffffff3) >> 0x2);
}

inline void tTriggers::tPFI_WDT_ModeSelect_Register::writePFI_WDT_ModeD1(nTriggers::tPFI_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI_WDT_ModeD1(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::readPFI_WDT_ModeD1(nMDBG::tStatus2* s)
{
   return getPFI_WDT_ModeD1(s);
}

inline tTriggers::tPFI_WDT_ModeSelect_Register& tTriggers::tPFI_WDT_ModeSelect_Register::setPFI_WDT_ModeD2(nTriggers::tPFI_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 nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::getPFI_WDT_ModeD2(nMDBG::tStatus2*) const
{
   return nTriggers::tPFI_WDT_Mode_t((_softCopy & ~0xffffffcf) >> 0x4);
}

inline void tTriggers::tPFI_WDT_ModeSelect_Register::writePFI_WDT_ModeD2(nTriggers::tPFI_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI_WDT_ModeD2(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::readPFI_WDT_ModeD2(nMDBG::tStatus2* s)
{
   return getPFI_WDT_ModeD2(s);
}

inline tTriggers::tPFI_WDT_ModeSelect_Register& tTriggers::tPFI_WDT_ModeSelect_Register::setPFI_WDT_ModeD3(nTriggers::tPFI_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 nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::getPFI_WDT_ModeD3(nMDBG::tStatus2*) const
{
   return nTriggers::tPFI_WDT_Mode_t((_softCopy & ~0xffffff3f) >> 0x6);
}

inline void tTriggers::tPFI_WDT_ModeSelect_Register::writePFI_WDT_ModeD3(nTriggers::tPFI_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI_WDT_ModeD3(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::readPFI_WDT_ModeD3(nMDBG::tStatus2* s)
{
   return getPFI_WDT_ModeD3(s);
}

inline tTriggers::tPFI_WDT_ModeSelect_Register& tTriggers::tPFI_WDT_ModeSelect_Register::setPFI_WDT_ModeD4(nTriggers::tPFI_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 nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::getPFI_WDT_ModeD4(nMDBG::tStatus2*) const
{
   return nTriggers::tPFI_WDT_Mode_t((_softCopy & ~0xfffffcff) >> 0x8);
}

inline void tTriggers::tPFI_WDT_ModeSelect_Register::writePFI_WDT_ModeD4(nTriggers::tPFI_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI_WDT_ModeD4(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::readPFI_WDT_ModeD4(nMDBG::tStatus2* s)
{
   return getPFI_WDT_ModeD4(s);
}

inline tTriggers::tPFI_WDT_ModeSelect_Register& tTriggers::tPFI_WDT_ModeSelect_Register::setPFI_WDT_ModeD5(nTriggers::tPFI_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 nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::getPFI_WDT_ModeD5(nMDBG::tStatus2*) const
{
   return nTriggers::tPFI_WDT_Mode_t((_softCopy & ~0xfffff3ff) >> 0xa);
}

inline void tTriggers::tPFI_WDT_ModeSelect_Register::writePFI_WDT_ModeD5(nTriggers::tPFI_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI_WDT_ModeD5(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::readPFI_WDT_ModeD5(nMDBG::tStatus2* s)
{
   return getPFI_WDT_ModeD5(s);
}

inline tTriggers::tPFI_WDT_ModeSelect_Register& tTriggers::tPFI_WDT_ModeSelect_Register::setPFI_WDT_ModeD6(nTriggers::tPFI_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 nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::getPFI_WDT_ModeD6(nMDBG::tStatus2*) const
{
   return nTriggers::tPFI_WDT_Mode_t((_softCopy & ~0xffffcfff) >> 0xc);
}

inline void tTriggers::tPFI_WDT_ModeSelect_Register::writePFI_WDT_ModeD6(nTriggers::tPFI_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI_WDT_ModeD6(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::readPFI_WDT_ModeD6(nMDBG::tStatus2* s)
{
   return getPFI_WDT_ModeD6(s);
}

inline tTriggers::tPFI_WDT_ModeSelect_Register& tTriggers::tPFI_WDT_ModeSelect_Register::setPFI_WDT_ModeD7(nTriggers::tPFI_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 nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::getPFI_WDT_ModeD7(nMDBG::tStatus2*) const
{
   return nTriggers::tPFI_WDT_Mode_t((_softCopy & ~0xffff3fff) >> 0xe);
}

inline void tTriggers::tPFI_WDT_ModeSelect_Register::writePFI_WDT_ModeD7(nTriggers::tPFI_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI_WDT_ModeD7(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::readPFI_WDT_ModeD7(nMDBG::tStatus2* s)
{
   return getPFI_WDT_ModeD7(s);
}

inline tTriggers::tPFI_WDT_ModeSelect_Register& tTriggers::tPFI_WDT_ModeSelect_Register::setPFI_WDT_ModeD8(nTriggers::tPFI_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 nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::getPFI_WDT_ModeD8(nMDBG::tStatus2*) const
{
   return nTriggers::tPFI_WDT_Mode_t((_softCopy & ~0xfffcffff) >> 0x10);
}

inline void tTriggers::tPFI_WDT_ModeSelect_Register::writePFI_WDT_ModeD8(nTriggers::tPFI_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI_WDT_ModeD8(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::readPFI_WDT_ModeD8(nMDBG::tStatus2* s)
{
   return getPFI_WDT_ModeD8(s);
}

inline tTriggers::tPFI_WDT_ModeSelect_Register& tTriggers::tPFI_WDT_ModeSelect_Register::setPFI_WDT_ModeD9(nTriggers::tPFI_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 nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::getPFI_WDT_ModeD9(nMDBG::tStatus2*) const
{
   return nTriggers::tPFI_WDT_Mode_t((_softCopy & ~0xfff3ffff) >> 0x12);
}

inline void tTriggers::tPFI_WDT_ModeSelect_Register::writePFI_WDT_ModeD9(nTriggers::tPFI_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI_WDT_ModeD9(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::readPFI_WDT_ModeD9(nMDBG::tStatus2* s)
{
   return getPFI_WDT_ModeD9(s);
}

inline tTriggers::tPFI_WDT_ModeSelect_Register& tTriggers::tPFI_WDT_ModeSelect_Register::setPFI_WDT_ModeD10(nTriggers::tPFI_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 nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::getPFI_WDT_ModeD10(nMDBG::tStatus2*) const
{
   return nTriggers::tPFI_WDT_Mode_t((_softCopy & ~0xffcfffff) >> 0x14);
}

inline void tTriggers::tPFI_WDT_ModeSelect_Register::writePFI_WDT_ModeD10(nTriggers::tPFI_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI_WDT_ModeD10(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::readPFI_WDT_ModeD10(nMDBG::tStatus2* s)
{
   return getPFI_WDT_ModeD10(s);
}

inline tTriggers::tPFI_WDT_ModeSelect_Register& tTriggers::tPFI_WDT_ModeSelect_Register::setPFI_WDT_ModeD11(nTriggers::tPFI_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 nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::getPFI_WDT_ModeD11(nMDBG::tStatus2*) const
{
   return nTriggers::tPFI_WDT_Mode_t((_softCopy & ~0xff3fffff) >> 0x16);
}

inline void tTriggers::tPFI_WDT_ModeSelect_Register::writePFI_WDT_ModeD11(nTriggers::tPFI_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI_WDT_ModeD11(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::readPFI_WDT_ModeD11(nMDBG::tStatus2* s)
{
   return getPFI_WDT_ModeD11(s);
}

inline tTriggers::tPFI_WDT_ModeSelect_Register& tTriggers::tPFI_WDT_ModeSelect_Register::setPFI_WDT_ModeD12(nTriggers::tPFI_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 nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::getPFI_WDT_ModeD12(nMDBG::tStatus2*) const
{
   return nTriggers::tPFI_WDT_Mode_t((_softCopy & ~0xfcffffff) >> 0x18);
}

inline void tTriggers::tPFI_WDT_ModeSelect_Register::writePFI_WDT_ModeD12(nTriggers::tPFI_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI_WDT_ModeD12(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::readPFI_WDT_ModeD12(nMDBG::tStatus2* s)
{
   return getPFI_WDT_ModeD12(s);
}

inline tTriggers::tPFI_WDT_ModeSelect_Register& tTriggers::tPFI_WDT_ModeSelect_Register::setPFI_WDT_ModeD13(nTriggers::tPFI_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 nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::getPFI_WDT_ModeD13(nMDBG::tStatus2*) const
{
   return nTriggers::tPFI_WDT_Mode_t((_softCopy & ~0xf3ffffff) >> 0x1a);
}

inline void tTriggers::tPFI_WDT_ModeSelect_Register::writePFI_WDT_ModeD13(nTriggers::tPFI_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI_WDT_ModeD13(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::readPFI_WDT_ModeD13(nMDBG::tStatus2* s)
{
   return getPFI_WDT_ModeD13(s);
}

inline tTriggers::tPFI_WDT_ModeSelect_Register& tTriggers::tPFI_WDT_ModeSelect_Register::setPFI_WDT_ModeD14(nTriggers::tPFI_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 nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::getPFI_WDT_ModeD14(nMDBG::tStatus2*) const
{
   return nTriggers::tPFI_WDT_Mode_t((_softCopy & ~0xcfffffff) >> 0x1c);
}

inline void tTriggers::tPFI_WDT_ModeSelect_Register::writePFI_WDT_ModeD14(nTriggers::tPFI_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI_WDT_ModeD14(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::readPFI_WDT_ModeD14(nMDBG::tStatus2* s)
{
   return getPFI_WDT_ModeD14(s);
}

inline tTriggers::tPFI_WDT_ModeSelect_Register& tTriggers::tPFI_WDT_ModeSelect_Register::setPFI_WDT_ModeD15(nTriggers::tPFI_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 nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::getPFI_WDT_ModeD15(nMDBG::tStatus2*) const
{
   return nTriggers::tPFI_WDT_Mode_t((_softCopy & ~0x3fffffff) >> 0x1e);
}

inline void tTriggers::tPFI_WDT_ModeSelect_Register::writePFI_WDT_ModeD15(nTriggers::tPFI_WDT_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPFI_WDT_ModeD15(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tPFI_WDT_Mode_t tTriggers::tPFI_WDT_ModeSelect_Register::readPFI_WDT_ModeD15(nMDBG::tStatus2* s)
{
   return getPFI_WDT_ModeD15(s);
}

inline tTriggers::tIntTriggerA_OutputSelectRegister_t::tIntTriggerA_OutputSelectRegister_t(u32 offset, u32 id)
 : kOffset(offset),
   kId(id)
{
   _softCopy = u8(0x0);
}

inline tTriggers::tIntTriggerA_OutputSelectRegister_t::tIntTriggerA_OutputSelectRegister_t()
 : kOffset((u32)~0),
   kId((u32)~0)
{
   _softCopy = u8(0x0);
}

inline void tTriggers::tIntTriggerA_OutputSelectRegister_t::initialize(u32 offset, u32 id)
{
   u32* mutableOffset = const_cast<u32*>(&this->kOffset);
   u32* mutableId     = const_cast<u32*>(&this->kId);
   *mutableOffset = offset;
   *mutableId = id;
}

inline tTriggers::tIntTriggerA_OutputSelectRegister_t::tRegisterMap* tTriggers::tIntTriggerA_OutputSelectRegister_t::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tIntTriggerA_OutputSelectRegister_t::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u8 tTriggers::tIntTriggerA_OutputSelectRegister_t::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tTriggers::tIntTriggerA_OutputSelectRegister_t::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 tTriggers::tIntTriggerA_OutputSelectRegister_t::writeRegister(u8 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   if (s && s->isFatal()) return;
   force = force || (_softCopy != fieldValue);
   _softCopy = fieldValue;
   flush(s, force);
}

inline u8 tTriggers::tIntTriggerA_OutputSelectRegister_t::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tTriggers::tIntTriggerA_OutputSelectRegister_t& tTriggers::tIntTriggerA_OutputSelectRegister_t::setIntTriggerA_i_Output_Select(nTriggers::tTrig_IntTriggerA_i_Output_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u8 newValue;   newValue = (_softCopy & 0x80) | ((u8(fieldValue) << 0x0) & ~0x80);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_IntTriggerA_i_Output_Select_t tTriggers::tIntTriggerA_OutputSelectRegister_t::getIntTriggerA_i_Output_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_IntTriggerA_i_Output_Select_t((_softCopy & ~0x80) >> 0x0);
}

inline void tTriggers::tIntTriggerA_OutputSelectRegister_t::writeIntTriggerA_i_Output_Select(nTriggers::tTrig_IntTriggerA_i_Output_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setIntTriggerA_i_Output_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_IntTriggerA_i_Output_Select_t tTriggers::tIntTriggerA_OutputSelectRegister_t::readIntTriggerA_i_Output_Select(nMDBG::tStatus2* s)
{
   return getIntTriggerA_i_Output_Select(s);
}

inline tTriggers::tIntTrigA_Filter_Register_Lo::tIntTrigA_Filter_Register_Lo()
{
   _softCopy = u16(0x0);
}

inline tTriggers::tIntTrigA_Filter_Register_Lo::tRegisterMap* tTriggers::tIntTrigA_Filter_Register_Lo::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tIntTrigA_Filter_Register_Lo::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tTriggers::tIntTrigA_Filter_Register_Lo::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tTriggers::tIntTrigA_Filter_Register_Lo::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 &= u16(0xffff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tTriggers::tIntTrigA_Filter_Register_Lo::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tTriggers::tIntTrigA_Filter_Register_Lo& tTriggers::tIntTrigA_Filter_Register_Lo::setITA0_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfff8) | ((u16(fieldValue) << 0x0) & ~0xfff8);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Select_t tTriggers::tIntTrigA_Filter_Register_Lo::getITA0_Filter_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Select_t((_softCopy & ~0xfff8) >> 0x0);
}

inline void tTriggers::tIntTrigA_Filter_Register_Lo::writeITA0_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setITA0_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Select_t tTriggers::tIntTrigA_Filter_Register_Lo::readITA0_Filter_Select(nMDBG::tStatus2* s)
{
   return getITA0_Filter_Select(s);
}

inline tTriggers::tIntTrigA_Filter_Register_Lo& tTriggers::tIntTrigA_Filter_Register_Lo::setITA1_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xff8f) | ((u16(fieldValue) << 0x4) & ~0xff8f);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Select_t tTriggers::tIntTrigA_Filter_Register_Lo::getITA1_Filter_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Select_t((_softCopy & ~0xff8f) >> 0x4);
}

inline void tTriggers::tIntTrigA_Filter_Register_Lo::writeITA1_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setITA1_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Select_t tTriggers::tIntTrigA_Filter_Register_Lo::readITA1_Filter_Select(nMDBG::tStatus2* s)
{
   return getITA1_Filter_Select(s);
}

inline tTriggers::tIntTrigA_Filter_Register_Lo& tTriggers::tIntTrigA_Filter_Register_Lo::setITA2_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xf8ff) | ((u16(fieldValue) << 0x8) & ~0xf8ff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Select_t tTriggers::tIntTrigA_Filter_Register_Lo::getITA2_Filter_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Select_t((_softCopy & ~0xf8ff) >> 0x8);
}

inline void tTriggers::tIntTrigA_Filter_Register_Lo::writeITA2_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setITA2_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Select_t tTriggers::tIntTrigA_Filter_Register_Lo::readITA2_Filter_Select(nMDBG::tStatus2* s)
{
   return getITA2_Filter_Select(s);
}

inline tTriggers::tIntTrigA_Filter_Register_Lo& tTriggers::tIntTrigA_Filter_Register_Lo::setITA3_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0x8fff) | ((u16(fieldValue) << 0xc) & ~0x8fff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Select_t tTriggers::tIntTrigA_Filter_Register_Lo::getITA3_Filter_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Select_t((_softCopy & ~0x8fff) >> 0xc);
}

inline void tTriggers::tIntTrigA_Filter_Register_Lo::writeITA3_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setITA3_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Select_t tTriggers::tIntTrigA_Filter_Register_Lo::readITA3_Filter_Select(nMDBG::tStatus2* s)
{
   return getITA3_Filter_Select(s);
}

inline tTriggers::tIntTrigA_Filter_Register_Hi::tIntTrigA_Filter_Register_Hi()
{
   _softCopy = u16(0x0);
}

inline tTriggers::tIntTrigA_Filter_Register_Hi::tRegisterMap* tTriggers::tIntTrigA_Filter_Register_Hi::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tIntTrigA_Filter_Register_Hi::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tTriggers::tIntTrigA_Filter_Register_Hi::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tTriggers::tIntTrigA_Filter_Register_Hi::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 &= u16(0xffff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tTriggers::tIntTrigA_Filter_Register_Hi::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tTriggers::tIntTrigA_Filter_Register_Hi& tTriggers::tIntTrigA_Filter_Register_Hi::setITA4_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfff8) | ((u16(fieldValue) << 0x0) & ~0xfff8);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Select_t tTriggers::tIntTrigA_Filter_Register_Hi::getITA4_Filter_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Select_t((_softCopy & ~0xfff8) >> 0x0);
}

inline void tTriggers::tIntTrigA_Filter_Register_Hi::writeITA4_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setITA4_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Select_t tTriggers::tIntTrigA_Filter_Register_Hi::readITA4_Filter_Select(nMDBG::tStatus2* s)
{
   return getITA4_Filter_Select(s);
}

inline tTriggers::tIntTrigA_Filter_Register_Hi& tTriggers::tIntTrigA_Filter_Register_Hi::setITA5_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xff8f) | ((u16(fieldValue) << 0x4) & ~0xff8f);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Select_t tTriggers::tIntTrigA_Filter_Register_Hi::getITA5_Filter_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Select_t((_softCopy & ~0xff8f) >> 0x4);
}

inline void tTriggers::tIntTrigA_Filter_Register_Hi::writeITA5_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setITA5_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Select_t tTriggers::tIntTrigA_Filter_Register_Hi::readITA5_Filter_Select(nMDBG::tStatus2* s)
{
   return getITA5_Filter_Select(s);
}

inline tTriggers::tIntTrigA_Filter_Register_Hi& tTriggers::tIntTrigA_Filter_Register_Hi::setITA6_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xf8ff) | ((u16(fieldValue) << 0x8) & ~0xf8ff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Select_t tTriggers::tIntTrigA_Filter_Register_Hi::getITA6_Filter_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Select_t((_softCopy & ~0xf8ff) >> 0x8);
}

inline void tTriggers::tIntTrigA_Filter_Register_Hi::writeITA6_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setITA6_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Select_t tTriggers::tIntTrigA_Filter_Register_Hi::readITA6_Filter_Select(nMDBG::tStatus2* s)
{
   return getITA6_Filter_Select(s);
}

inline tTriggers::tIntTrigA_Filter_Register_Hi& tTriggers::tIntTrigA_Filter_Register_Hi::setITA7_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0x8fff) | ((u16(fieldValue) << 0xc) & ~0x8fff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Select_t tTriggers::tIntTrigA_Filter_Register_Hi::getITA7_Filter_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Select_t((_softCopy & ~0x8fff) >> 0xc);
}

inline void tTriggers::tIntTrigA_Filter_Register_Hi::writeITA7_Filter_Select(nTriggers::tTrig_Filter_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setITA7_Filter_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Select_t tTriggers::tIntTrigA_Filter_Register_Hi::readITA7_Filter_Select(nMDBG::tStatus2* s)
{
   return getITA7_Filter_Select(s);
}

inline tTriggers::tTrig_Filter_Settings1_Register::tTrig_Filter_Settings1_Register()
{
   _softCopy = u16(0x0);
}

inline tTriggers::tTrig_Filter_Settings1_Register::tRegisterMap* tTriggers::tTrig_Filter_Settings1_Register::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tTrig_Filter_Settings1_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tTriggers::tTrig_Filter_Settings1_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tTriggers::tTrig_Filter_Settings1_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 &= u16(0xffff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tTriggers::tTrig_Filter_Settings1_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tTriggers::tTrig_Filter_Settings1_Register& tTriggers::tTrig_Filter_Settings1_Register::setTrig_Filter_Custom_Period_1(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfe00) | ((u16(fieldValue) << 0x0) & ~0xfe00);
   setRegister(newValue, s);
   return *this;
}

inline u16 tTriggers::tTrig_Filter_Settings1_Register::getTrig_Filter_Custom_Period_1(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfe00) >> 0x0);
}

inline void tTriggers::tTrig_Filter_Settings1_Register::writeTrig_Filter_Custom_Period_1(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setTrig_Filter_Custom_Period_1(fieldValue, s);
   flush(s, force);
}
inline u16 tTriggers::tTrig_Filter_Settings1_Register::readTrig_Filter_Custom_Period_1(nMDBG::tStatus2* s)
{
   return getTrig_Filter_Custom_Period_1(s);
}

inline tTriggers::tTrig_Filter_Settings1_Register& tTriggers::tTrig_Filter_Settings1_Register::setTrig_Filter_Custom_Timebase_1(nTriggers::tTrig_Filter_Custom_Timebase_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xf3ff) | ((u16(fieldValue) << 0xa) & ~0xf3ff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Custom_Timebase_t tTriggers::tTrig_Filter_Settings1_Register::getTrig_Filter_Custom_Timebase_1(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Custom_Timebase_t((_softCopy & ~0xf3ff) >> 0xa);
}

inline void tTriggers::tTrig_Filter_Settings1_Register::writeTrig_Filter_Custom_Timebase_1(nTriggers::tTrig_Filter_Custom_Timebase_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setTrig_Filter_Custom_Timebase_1(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Custom_Timebase_t tTriggers::tTrig_Filter_Settings1_Register::readTrig_Filter_Custom_Timebase_1(nMDBG::tStatus2* s)
{
   return getTrig_Filter_Custom_Timebase_1(s);
}

inline tTriggers::tTrig_Filter_Settings1_Register& tTriggers::tTrig_Filter_Settings1_Register::setTrig_Filter_Ext_Signal_Select(nTriggers::tTrig_Filter_Ext_Signal_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0x1fff) | ((u16(fieldValue) << 0xd) & ~0x1fff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Ext_Signal_Select_t tTriggers::tTrig_Filter_Settings1_Register::getTrig_Filter_Ext_Signal_Select(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Ext_Signal_Select_t((_softCopy & ~0x1fff) >> 0xd);
}

inline void tTriggers::tTrig_Filter_Settings1_Register::writeTrig_Filter_Ext_Signal_Select(nTriggers::tTrig_Filter_Ext_Signal_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setTrig_Filter_Ext_Signal_Select(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Ext_Signal_Select_t tTriggers::tTrig_Filter_Settings1_Register::readTrig_Filter_Ext_Signal_Select(nMDBG::tStatus2* s)
{
   return getTrig_Filter_Ext_Signal_Select(s);
}

inline tTriggers::tTrig_Filter_Settings2_Register::tTrig_Filter_Settings2_Register()
{
   _softCopy = u16(0x0);
}

inline tTriggers::tTrig_Filter_Settings2_Register::tRegisterMap* tTriggers::tTrig_Filter_Settings2_Register::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tTrig_Filter_Settings2_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tTriggers::tTrig_Filter_Settings2_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tTriggers::tTrig_Filter_Settings2_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 &= u16(0xffff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tTriggers::tTrig_Filter_Settings2_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tTriggers::tTrig_Filter_Settings2_Register& tTriggers::tTrig_Filter_Settings2_Register::setTrig_Filter_Custom_Period_2(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xfe00) | ((u16(fieldValue) << 0x0) & ~0xfe00);
   setRegister(newValue, s);
   return *this;
}

inline u16 tTriggers::tTrig_Filter_Settings2_Register::getTrig_Filter_Custom_Period_2(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xfe00) >> 0x0);
}

inline void tTriggers::tTrig_Filter_Settings2_Register::writeTrig_Filter_Custom_Period_2(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setTrig_Filter_Custom_Period_2(fieldValue, s);
   flush(s, force);
}
inline u16 tTriggers::tTrig_Filter_Settings2_Register::readTrig_Filter_Custom_Period_2(nMDBG::tStatus2* s)
{
   return getTrig_Filter_Custom_Period_2(s);
}

inline tTriggers::tTrig_Filter_Settings2_Register& tTriggers::tTrig_Filter_Settings2_Register::setTrig_Filter_Custom_Timebase_2(nTriggers::tTrig_Filter_Custom_Timebase_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xf3ff) | ((u16(fieldValue) << 0xa) & ~0xf3ff);
   setRegister(newValue, s);
   return *this;
}

inline nTriggers::tTrig_Filter_Custom_Timebase_t tTriggers::tTrig_Filter_Settings2_Register::getTrig_Filter_Custom_Timebase_2(nMDBG::tStatus2*) const
{
   return nTriggers::tTrig_Filter_Custom_Timebase_t((_softCopy & ~0xf3ff) >> 0xa);
}

inline void tTriggers::tTrig_Filter_Settings2_Register::writeTrig_Filter_Custom_Timebase_2(nTriggers::tTrig_Filter_Custom_Timebase_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setTrig_Filter_Custom_Timebase_2(fieldValue, s);
   flush(s, force);
}
inline nTriggers::tTrig_Filter_Custom_Timebase_t tTriggers::tTrig_Filter_Settings2_Register::readTrig_Filter_Custom_Timebase_2(nMDBG::tStatus2* s)
{
   return getTrig_Filter_Custom_Timebase_2(s);
}

inline tTriggers::tPLL_LockCount_Register::tPLL_LockCount_Register()
{
   _softCopy = u16(0x0);
}

inline tTriggers::tPLL_LockCount_Register::tRegisterMap* tTriggers::tPLL_LockCount_Register::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tPLL_LockCount_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tTriggers::tPLL_LockCount_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tTriggers::tPLL_LockCount_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 &= u16(0xffff);
      _softCopy |= u16(0x0);
      markClean(s);
   }
}

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

inline u16 tTriggers::tPLL_LockCount_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tTriggers::tPLL_LockCount_Register& tTriggers::tPLL_LockCount_Register::setPLL_LockCount(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0x0) | ((u16(fieldValue) << 0x0) & ~0x0);
   setRegister(newValue, s);
   return *this;
}

inline u16 tTriggers::tPLL_LockCount_Register::getPLL_LockCount(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0x0) >> 0x0);
}

inline void tTriggers::tPLL_LockCount_Register::writePLL_LockCount(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setPLL_LockCount(fieldValue, s);
   flush(s, force);
}
inline u16 tTriggers::tPLL_LockCount_Register::readPLL_LockCount(nMDBG::tStatus2* s)
{
   return getPLL_LockCount(s);
}

inline tTriggers::tSync100_Repeat_Count_Register::tSync100_Repeat_Count_Register()
{
   _softCopy = u8(0x0);
}

inline tTriggers::tSync100_Repeat_Count_Register::tRegisterMap* tTriggers::tSync100_Repeat_Count_Register::registerMap(void)
{
   return _regMap;
}

inline void tTriggers::tSync100_Repeat_Count_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u8 tTriggers::tSync100_Repeat_Count_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tTriggers::tSync100_Repeat_Count_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 tTriggers::tSync100_Repeat_Count_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 tTriggers::tSync100_Repeat_Count_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


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

inline u8 tTriggers::tSync100_Repeat_Count_Register::getSync100_Repeat_Count(nMDBG::tStatus2*) const
{
   return u8((_softCopy & ~0x0) >> 0x0);
}

inline void tTriggers::tSync100_Repeat_Count_Register::writeSync100_Repeat_Count(u8 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setSync100_Repeat_Count(fieldValue, s);
   flush(s, force);
}
inline u8 tTriggers::tSync100_Repeat_Count_Register::readSync100_Repeat_Count(nMDBG::tStatus2* s)
{
   return getSync100_Repeat_Count(s);
}

#endif


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