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

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

inline u16 tOutTimer::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 tOutTimer::tReg32IODirect32::write(
   tBusSpaceReference addrSpace,
   u32 offset,
   u32 value,
   nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   addrSpace.write32(offset, value);
}

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

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

inline tOutTimer::tCommand_1_Register::tRegisterMap* tOutTimer::tCommand_1_Register::registerMap(void)
{
   return _regMap;
}

inline void tOutTimer::tCommand_1_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline void tOutTimer::tCommand_1_Register::writeSTART1_Pulse(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x0) & ~0xfffffffe,s);
}
inline void tOutTimer::tCommand_1_Register::writeBC_Switch_Load_On_TC(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x4) & ~0xffffffef,s);
}
inline void tOutTimer::tCommand_1_Register::writeUC_Switch_Load_On_TC(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x5) & ~0xffffffdf,s);
}
inline void tOutTimer::tCommand_1_Register::writeUC_Switch_Load_On_BC_TC(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x6) & ~0xffffffbf,s);
}
inline void tOutTimer::tCommand_1_Register::writeUI_Switch_Load_On_TC(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x7) & ~0xffffff7f,s);
}
inline void tOutTimer::tCommand_1_Register::writeUI_Switch_Load_On_UC_TC(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x8) & ~0xfffffeff,s);
}
inline void tOutTimer::tCommand_1_Register::writeUI_Switch_Load_On_BC_TC(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x9) & ~0xfffffdff,s);
}
inline void tOutTimer::tCommand_1_Register::writeUI_Cancel_Load_Switch(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0xc) & ~0xffffefff,s);
}
inline void tOutTimer::tCommand_1_Register::writeEnd_On_UC_TC(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0xe) & ~0xffffbfff,s);
}
inline void tOutTimer::tCommand_1_Register::writeEnd_On_BC_TC(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0xf) & ~0xffff7fff,s);
}
inline void tOutTimer::tCommand_1_Register::writeUpdate_Pulse(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x10) & ~0xfffeffff,s);
}
inline void tOutTimer::tCommand_1_Register::writeBC_Load(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x15) & ~0xffdfffff,s);
}
inline void tOutTimer::tCommand_1_Register::writeBC_Arm(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x16) & ~0xffbfffff,s);
}
inline void tOutTimer::tCommand_1_Register::writeUC_Load(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x17) & ~0xff7fffff,s);
}
inline void tOutTimer::tCommand_1_Register::writeUC_Arm(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x18) & ~0xfeffffff,s);
}
inline void tOutTimer::tCommand_1_Register::writeUI_Load(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x19) & ~0xfdffffff,s);
}
inline void tOutTimer::tCommand_1_Register::writeUI_Arm(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x1a) & ~0xfbffffff,s);
}
inline void tOutTimer::tCommand_1_Register::writeDisarm(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x1d) & ~0xdfffffff,s);
}
inline tOutTimer::tStatus_1_Register::tStatus_1_Register()
{
   _softCopy = u32(0x0);
}

inline tOutTimer::tStatus_1_Register::tRegisterMap* tOutTimer::tStatus_1_Register::registerMap(void)
{
   return _regMap;
}

inline void tOutTimer::tStatus_1_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline u32 tOutTimer::tStatus_1_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setBC_Armed_St(nOutTimer::tOutTimer_Armed_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffffe) | ((u32(fieldValue) << 0x0) & ~0xfffffffe);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Armed_t tOutTimer::tStatus_1_Register::getBC_Armed_St(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Armed_t((_softCopy & ~0xfffffffe) >> 0x0);
}

inline nOutTimer::tOutTimer_Armed_t tOutTimer::tStatus_1_Register::readBC_Armed_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getBC_Armed_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setBC_Next_Load_Source_St(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffffd) | ((u32(fieldValue) << 0x1) & ~0xfffffffd);
   setRegister(newValue, s);
   return *this;
}

inline u32 tOutTimer::tStatus_1_Register::getBC_Next_Load_Source_St(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xfffffffd) >> 0x1);
}

inline u32 tOutTimer::tStatus_1_Register::readBC_Next_Load_Source_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getBC_Next_Load_Source_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setWrite_Too_Fast_St(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffffb) | ((u32(fieldValue) << 0x2) & ~0xfffffffb);
   setRegister(newValue, s);
   return *this;
}

inline u32 tOutTimer::tStatus_1_Register::getWrite_Too_Fast_St(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xfffffffb) >> 0x2);
}

inline u32 tOutTimer::tStatus_1_Register::readWrite_Too_Fast_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getWrite_Too_Fast_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setBC_Q_St(nOutTimer::tOutTimer_BC_Q_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffff7) | ((u32(fieldValue) << 0x3) & ~0xfffffff7);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_BC_Q_t tOutTimer::tStatus_1_Register::getBC_Q_St(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_BC_Q_t((_softCopy & ~0xfffffff7) >> 0x3);
}

inline nOutTimer::tOutTimer_BC_Q_t tOutTimer::tStatus_1_Register::readBC_Q_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getBC_Q_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setBC_TC_Trigger_Error_St(nOutTimer::tOutTimer_Error_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffffef) | ((u32(fieldValue) << 0x4) & ~0xffffffef);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Error_t tOutTimer::tStatus_1_Register::getBC_TC_Trigger_Error_St(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Error_t((_softCopy & ~0xffffffef) >> 0x4);
}

inline nOutTimer::tOutTimer_Error_t tOutTimer::tStatus_1_Register::readBC_TC_Trigger_Error_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getBC_TC_Trigger_Error_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setUI_Armed_St(nOutTimer::tOutTimer_Armed_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffffdf) | ((u32(fieldValue) << 0x5) & ~0xffffffdf);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Armed_t tOutTimer::tStatus_1_Register::getUI_Armed_St(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Armed_t((_softCopy & ~0xffffffdf) >> 0x5);
}

inline nOutTimer::tOutTimer_Armed_t tOutTimer::tStatus_1_Register::readUI_Armed_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getUI_Armed_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setUI_Next_Load_Source_St(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffffbf) | ((u32(fieldValue) << 0x6) & ~0xffffffbf);
   setRegister(newValue, s);
   return *this;
}

inline u32 tOutTimer::tStatus_1_Register::getUI_Next_Load_Source_St(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xffffffbf) >> 0x6);
}

inline u32 tOutTimer::tStatus_1_Register::readUI_Next_Load_Source_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getUI_Next_Load_Source_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setUI_Load_Switch_Pending_St(nOutTimer::tOutTimer_UI_Load_Switch_Pending_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffff7f) | ((u32(fieldValue) << 0x7) & ~0xffffff7f);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_UI_Load_Switch_Pending_t tOutTimer::tStatus_1_Register::getUI_Load_Switch_Pending_St(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_UI_Load_Switch_Pending_t((_softCopy & ~0xffffff7f) >> 0x7);
}

inline nOutTimer::tOutTimer_UI_Load_Switch_Pending_t tOutTimer::tStatus_1_Register::readUI_Load_Switch_Pending_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getUI_Load_Switch_Pending_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setUI_Count_Enabled_St(nOutTimer::tOutTimer_UI_Count_Enabled_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffeff) | ((u32(fieldValue) << 0x8) & ~0xfffffeff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_UI_Count_Enabled_t tOutTimer::tStatus_1_Register::getUI_Count_Enabled_St(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_UI_Count_Enabled_t((_softCopy & ~0xfffffeff) >> 0x8);
}

inline nOutTimer::tOutTimer_UI_Count_Enabled_t tOutTimer::tStatus_1_Register::readUI_Count_Enabled_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getUI_Count_Enabled_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setUI_Q_St(nOutTimer::tOutTimer_UI_Q_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffdff) | ((u32(fieldValue) << 0x9) & ~0xfffffdff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_UI_Q_t tOutTimer::tStatus_1_Register::getUI_Q_St(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_UI_Q_t((_softCopy & ~0xfffffdff) >> 0x9);
}

inline nOutTimer::tOutTimer_UI_Q_t tOutTimer::tStatus_1_Register::readUI_Q_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getUI_Q_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setTMRDACWRs_In_Progress_St(nOutTimer::tOutTimer_TMRDACWRs_In_Progress_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffbff) | ((u32(fieldValue) << 0xa) & ~0xfffffbff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_TMRDACWRs_In_Progress_t tOutTimer::tStatus_1_Register::getTMRDACWRs_In_Progress_St(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_TMRDACWRs_In_Progress_t((_softCopy & ~0xfffffbff) >> 0xa);
}

inline nOutTimer::tOutTimer_TMRDACWRs_In_Progress_t tOutTimer::tStatus_1_Register::readTMRDACWRs_In_Progress_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getTMRDACWRs_In_Progress_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setBC_Gate_St(nOutTimer::tOutTimer_BC_Gate_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffff7ff) | ((u32(fieldValue) << 0xb) & ~0xfffff7ff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_BC_Gate_t tOutTimer::tStatus_1_Register::getBC_Gate_St(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_BC_Gate_t((_softCopy & ~0xfffff7ff) >> 0xb);
}

inline nOutTimer::tOutTimer_BC_Gate_t tOutTimer::tStatus_1_Register::readBC_Gate_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getBC_Gate_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setExternal_Gate_St(nOutTimer::tOutTimer_External_Gate_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffefff) | ((u32(fieldValue) << 0xc) & ~0xffffefff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_External_Gate_t tOutTimer::tStatus_1_Register::getExternal_Gate_St(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_External_Gate_t((_softCopy & ~0xffffefff) >> 0xc);
}

inline nOutTimer::tOutTimer_External_Gate_t tOutTimer::tStatus_1_Register::readExternal_Gate_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getExternal_Gate_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setUC_Q_St(nOutTimer::tOutTimer_UC_Q_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffdfff) | ((u32(fieldValue) << 0xd) & ~0xffffdfff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_UC_Q_t tOutTimer::tStatus_1_Register::getUC_Q_St(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_UC_Q_t((_softCopy & ~0xffffdfff) >> 0xd);
}

inline nOutTimer::tOutTimer_UC_Q_t tOutTimer::tStatus_1_Register::readUC_Q_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getUC_Q_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setUC_Armed_St(nOutTimer::tOutTimer_Armed_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffbfff) | ((u32(fieldValue) << 0xe) & ~0xffffbfff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Armed_t tOutTimer::tStatus_1_Register::getUC_Armed_St(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Armed_t((_softCopy & ~0xffffbfff) >> 0xe);
}

inline nOutTimer::tOutTimer_Armed_t tOutTimer::tStatus_1_Register::readUC_Armed_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getUC_Armed_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setUC_Next_Load_Source_St(nOutTimer::tOutTimer_Load_Source_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffff7fff) | ((u32(fieldValue) << 0xf) & ~0xffff7fff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Load_Source_t tOutTimer::tStatus_1_Register::getUC_Next_Load_Source_St(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Load_Source_t((_softCopy & ~0xffff7fff) >> 0xf);
}

inline nOutTimer::tOutTimer_Load_Source_t tOutTimer::tStatus_1_Register::readUC_Next_Load_Source_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getUC_Next_Load_Source_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setFIFO_Request_St(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffdffff) | ((u32(fieldValue) << 0x11) & ~0xfffdffff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tOutTimer::tStatus_1_Register::getFIFO_Request_St(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xfffdffff) >> 0x11);
}

inline u32 tOutTimer::tStatus_1_Register::readFIFO_Request_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getFIFO_Request_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setUPDATE_St(nOutTimer::tOutTimer_Trigger_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffdfffff) | ((u32(fieldValue) << 0x15) & ~0xffdfffff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Trigger_t tOutTimer::tStatus_1_Register::getUPDATE_St(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Trigger_t((_softCopy & ~0xffdfffff) >> 0x15);
}

inline nOutTimer::tOutTimer_Trigger_t tOutTimer::tStatus_1_Register::readUPDATE_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getUPDATE_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setUC_TC_St(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffbfffff) | ((u32(fieldValue) << 0x16) & ~0xffbfffff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tOutTimer::tStatus_1_Register::getUC_TC_St(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xffbfffff) >> 0x16);
}

inline u32 tOutTimer::tStatus_1_Register::readUC_TC_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getUC_TC_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setBC_TC_St(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xff7fffff) | ((u32(fieldValue) << 0x17) & ~0xff7fffff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tOutTimer::tStatus_1_Register::getBC_TC_St(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xff7fffff) >> 0x17);
}

inline u32 tOutTimer::tStatus_1_Register::readBC_TC_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getBC_TC_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setSTART1_St(nOutTimer::tOutTimer_Trigger_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfeffffff) | ((u32(fieldValue) << 0x18) & ~0xfeffffff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Trigger_t tOutTimer::tStatus_1_Register::getSTART1_St(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Trigger_t((_softCopy & ~0xfeffffff) >> 0x18);
}

inline nOutTimer::tOutTimer_Trigger_t tOutTimer::tStatus_1_Register::readSTART1_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getSTART1_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setOverrun_St(nOutTimer::tOutTimer_Error_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfdffffff) | ((u32(fieldValue) << 0x19) & ~0xfdffffff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Error_t tOutTimer::tStatus_1_Register::getOverrun_St(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Error_t((_softCopy & ~0xfdffffff) >> 0x19);
}

inline nOutTimer::tOutTimer_Error_t tOutTimer::tStatus_1_Register::readOverrun_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getOverrun_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setUnderflow_St(nOutTimer::tOutTimer_Error_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfbffffff) | ((u32(fieldValue) << 0x1a) & ~0xfbffffff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Error_t tOutTimer::tStatus_1_Register::getUnderflow_St(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Error_t((_softCopy & ~0xfbffffff) >> 0x1a);
}

inline nOutTimer::tOutTimer_Error_t tOutTimer::tStatus_1_Register::readUnderflow_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getUnderflow_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setBC_TC_Error_St(nOutTimer::tOutTimer_Error_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xf7ffffff) | ((u32(fieldValue) << 0x1b) & ~0xf7ffffff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Error_t tOutTimer::tStatus_1_Register::getBC_TC_Error_St(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Error_t((_softCopy & ~0xf7ffffff) >> 0x1b);
}

inline nOutTimer::tOutTimer_Error_t tOutTimer::tStatus_1_Register::readBC_TC_Error_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getBC_TC_Error_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setFIFO_Empty_St(nOutTimer::tOutTimer_FIFO_Empty_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xefffffff) | ((u32(fieldValue) << 0x1c) & ~0xefffffff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_FIFO_Empty_t tOutTimer::tStatus_1_Register::getFIFO_Empty_St(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_FIFO_Empty_t((_softCopy & ~0xefffffff) >> 0x1c);
}

inline nOutTimer::tOutTimer_FIFO_Empty_t tOutTimer::tStatus_1_Register::readFIFO_Empty_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getFIFO_Empty_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setFIFO_Half_Full_St(nOutTimer::tOutTimer_FIFO_Half_Full_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xdfffffff) | ((u32(fieldValue) << 0x1d) & ~0xdfffffff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_FIFO_Half_Full_t tOutTimer::tStatus_1_Register::getFIFO_Half_Full_St(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_FIFO_Half_Full_t((_softCopy & ~0xdfffffff) >> 0x1d);
}

inline nOutTimer::tOutTimer_FIFO_Half_Full_t tOutTimer::tStatus_1_Register::readFIFO_Half_Full_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getFIFO_Half_Full_St(s);
}

inline tOutTimer::tStatus_1_Register& tOutTimer::tStatus_1_Register::setFIFO_Full_St(nOutTimer::tOutTimer_FIFO_Full_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xbfffffff) | ((u32(fieldValue) << 0x1e) & ~0xbfffffff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_FIFO_Full_t tOutTimer::tStatus_1_Register::getFIFO_Full_St(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_FIFO_Full_t((_softCopy & ~0xbfffffff) >> 0x1e);
}

inline nOutTimer::tOutTimer_FIFO_Full_t tOutTimer::tStatus_1_Register::readFIFO_Full_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getFIFO_Full_St(s);
}

inline tOutTimer::tUI_Load_A_Register::tUI_Load_A_Register()
{
   _softCopy = u32(0x0);
}

inline tOutTimer::tUI_Load_A_Register::tRegisterMap* tOutTimer::tUI_Load_A_Register::registerMap(void)
{
   return _regMap;
}

inline void tOutTimer::tUI_Load_A_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u32 tOutTimer::tUI_Load_A_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tOutTimer::tUI_Load_A_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 tOutTimer::tUI_Load_A_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 tOutTimer::tUI_Load_A_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


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

inline u32 tOutTimer::tUI_Load_A_Register::getUI_Load_A(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline void tOutTimer::tUI_Load_A_Register::writeUI_Load_A(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setUI_Load_A(fieldValue, s);
   flush(s, force);
}
inline u32 tOutTimer::tUI_Load_A_Register::readUI_Load_A(nMDBG::tStatus2* s)
{
   return getUI_Load_A(s);
}

inline tOutTimer::tUI_Save_Register::tUI_Save_Register()
{
   _softCopy = u32(0x0);
}

inline tOutTimer::tUI_Save_Register::tRegisterMap* tOutTimer::tUI_Save_Register::registerMap(void)
{
   return _regMap;
}

inline void tOutTimer::tUI_Save_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline u32 tOutTimer::tUI_Save_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

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

inline u32 tOutTimer::tUI_Save_Register::getUI_Save(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline u32 tOutTimer::tUI_Save_Register::readUI_Save(nMDBG::tStatus2* s)
{
   refresh(s);
   return getUI_Save(s);
}

inline tOutTimer::tUI_Load_B_Register::tUI_Load_B_Register()
{
   _softCopy = u32(0x0);
}

inline tOutTimer::tUI_Load_B_Register::tRegisterMap* tOutTimer::tUI_Load_B_Register::registerMap(void)
{
   return _regMap;
}

inline void tOutTimer::tUI_Load_B_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u32 tOutTimer::tUI_Load_B_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tOutTimer::tUI_Load_B_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 tOutTimer::tUI_Load_B_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 tOutTimer::tUI_Load_B_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


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

inline u32 tOutTimer::tUI_Load_B_Register::getUI_Load_B(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline void tOutTimer::tUI_Load_B_Register::writeUI_Load_B(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setUI_Load_B(fieldValue, s);
   flush(s, force);
}
inline u32 tOutTimer::tUI_Load_B_Register::readUI_Load_B(nMDBG::tStatus2* s)
{
   return getUI_Load_B(s);
}

inline tOutTimer::tUC_Load_A_Register::tUC_Load_A_Register()
{
   _softCopy = u32(0x0);
}

inline tOutTimer::tUC_Load_A_Register::tRegisterMap* tOutTimer::tUC_Load_A_Register::registerMap(void)
{
   return _regMap;
}

inline void tOutTimer::tUC_Load_A_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u32 tOutTimer::tUC_Load_A_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tOutTimer::tUC_Load_A_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 tOutTimer::tUC_Load_A_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 tOutTimer::tUC_Load_A_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


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

inline u32 tOutTimer::tUC_Load_A_Register::getUC_Load_A(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline void tOutTimer::tUC_Load_A_Register::writeUC_Load_A(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setUC_Load_A(fieldValue, s);
   flush(s, force);
}
inline u32 tOutTimer::tUC_Load_A_Register::readUC_Load_A(nMDBG::tStatus2* s)
{
   return getUC_Load_A(s);
}

inline tOutTimer::tUC_Save_Register::tUC_Save_Register()
{
   _softCopy = u32(0x0);
}

inline tOutTimer::tUC_Save_Register::tRegisterMap* tOutTimer::tUC_Save_Register::registerMap(void)
{
   return _regMap;
}

inline void tOutTimer::tUC_Save_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline u32 tOutTimer::tUC_Save_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

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

inline u32 tOutTimer::tUC_Save_Register::getUC_Save(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline u32 tOutTimer::tUC_Save_Register::readUC_Save(nMDBG::tStatus2* s)
{
   refresh(s);
   return getUC_Save(s);
}

inline tOutTimer::tUC_Load_B_Register::tUC_Load_B_Register()
{
   _softCopy = u32(0x0);
}

inline tOutTimer::tUC_Load_B_Register::tRegisterMap* tOutTimer::tUC_Load_B_Register::registerMap(void)
{
   return _regMap;
}

inline void tOutTimer::tUC_Load_B_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u32 tOutTimer::tUC_Load_B_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tOutTimer::tUC_Load_B_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 tOutTimer::tUC_Load_B_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 tOutTimer::tUC_Load_B_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


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

inline u32 tOutTimer::tUC_Load_B_Register::getUC_Load_B(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline void tOutTimer::tUC_Load_B_Register::writeUC_Load_B(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setUC_Load_B(fieldValue, s);
   flush(s, force);
}
inline u32 tOutTimer::tUC_Load_B_Register::readUC_Load_B(nMDBG::tStatus2* s)
{
   return getUC_Load_B(s);
}

inline tOutTimer::tBC_Load_A_Register::tBC_Load_A_Register()
{
   _softCopy = u32(0x0);
}

inline tOutTimer::tBC_Load_A_Register::tRegisterMap* tOutTimer::tBC_Load_A_Register::registerMap(void)
{
   return _regMap;
}

inline void tOutTimer::tBC_Load_A_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u32 tOutTimer::tBC_Load_A_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tOutTimer::tBC_Load_A_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 tOutTimer::tBC_Load_A_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 tOutTimer::tBC_Load_A_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


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

inline u32 tOutTimer::tBC_Load_A_Register::getBC_Load_A(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline void tOutTimer::tBC_Load_A_Register::writeBC_Load_A(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setBC_Load_A(fieldValue, s);
   flush(s, force);
}
inline u32 tOutTimer::tBC_Load_A_Register::readBC_Load_A(nMDBG::tStatus2* s)
{
   return getBC_Load_A(s);
}

inline tOutTimer::tBC_Save_Register::tBC_Save_Register()
{
   _softCopy = u32(0x0);
}

inline tOutTimer::tBC_Save_Register::tRegisterMap* tOutTimer::tBC_Save_Register::registerMap(void)
{
   return _regMap;
}

inline void tOutTimer::tBC_Save_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline u32 tOutTimer::tBC_Save_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

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

inline u32 tOutTimer::tBC_Save_Register::getBC_Save(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline u32 tOutTimer::tBC_Save_Register::readBC_Save(nMDBG::tStatus2* s)
{
   refresh(s);
   return getBC_Save(s);
}

inline tOutTimer::tBC_Load_B_Register::tBC_Load_B_Register()
{
   _softCopy = u32(0x0);
}

inline tOutTimer::tBC_Load_B_Register::tRegisterMap* tOutTimer::tBC_Load_B_Register::registerMap(void)
{
   return _regMap;
}

inline void tOutTimer::tBC_Load_B_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u32 tOutTimer::tBC_Load_B_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tOutTimer::tBC_Load_B_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 tOutTimer::tBC_Load_B_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 tOutTimer::tBC_Load_B_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


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

inline u32 tOutTimer::tBC_Load_B_Register::getBC_Load_B(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0x0) >> 0x0);
}

inline void tOutTimer::tBC_Load_B_Register::writeBC_Load_B(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setBC_Load_B(fieldValue, s);
   flush(s, force);
}
inline u32 tOutTimer::tBC_Load_B_Register::readBC_Load_B(nMDBG::tStatus2* s)
{
   return getBC_Load_B(s);
}

inline tOutTimer::tMode_1_Register::tMode_1_Register()
{
   _softCopy = u32(0x0);
}

inline tOutTimer::tMode_1_Register::tRegisterMap* tOutTimer::tMode_1_Register::registerMap(void)
{
   return _regMap;
}

inline void tOutTimer::tMode_1_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u32 tOutTimer::tMode_1_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tOutTimer::tMode_1_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 tOutTimer::tMode_1_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 tOutTimer::tMode_1_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tOutTimer::tMode_1_Register& tOutTimer::tMode_1_Register::setBC_Write_Switch(nOutTimer::tOutTimer_Write_Switch_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffffe) | ((u32(fieldValue) << 0x0) & ~0xfffffffe);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Write_Switch_t tOutTimer::tMode_1_Register::getBC_Write_Switch(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Write_Switch_t((_softCopy & ~0xfffffffe) >> 0x0);
}

inline void tOutTimer::tMode_1_Register::writeBC_Write_Switch(nOutTimer::tOutTimer_Write_Switch_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setBC_Write_Switch(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimer_Write_Switch_t tOutTimer::tMode_1_Register::readBC_Write_Switch(nMDBG::tStatus2* s)
{
   return getBC_Write_Switch(s);
}

inline tOutTimer::tMode_1_Register& tOutTimer::tMode_1_Register::setBC_Reload_Mode(nOutTimer::tOutTimer_BC_Reload_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffffd) | ((u32(fieldValue) << 0x1) & ~0xfffffffd);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_BC_Reload_Mode_t tOutTimer::tMode_1_Register::getBC_Reload_Mode(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_BC_Reload_Mode_t((_softCopy & ~0xfffffffd) >> 0x1);
}

inline void tOutTimer::tMode_1_Register::writeBC_Reload_Mode(nOutTimer::tOutTimer_BC_Reload_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setBC_Reload_Mode(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimer_BC_Reload_Mode_t tOutTimer::tMode_1_Register::readBC_Reload_Mode(nMDBG::tStatus2* s)
{
   return getBC_Reload_Mode(s);
}

inline tOutTimer::tMode_1_Register& tOutTimer::tMode_1_Register::setBC_Initial_Load_Source(nOutTimer::tOutTimer_Load_Source_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffffb) | ((u32(fieldValue) << 0x2) & ~0xfffffffb);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Load_Source_t tOutTimer::tMode_1_Register::getBC_Initial_Load_Source(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Load_Source_t((_softCopy & ~0xfffffffb) >> 0x2);
}

inline void tOutTimer::tMode_1_Register::writeBC_Initial_Load_Source(nOutTimer::tOutTimer_Load_Source_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setBC_Initial_Load_Source(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimer_Load_Source_t tOutTimer::tMode_1_Register::readBC_Initial_Load_Source(nMDBG::tStatus2* s)
{
   return getBC_Initial_Load_Source(s);
}

inline tOutTimer::tMode_1_Register& tOutTimer::tMode_1_Register::setUI_Write_Switch(nOutTimer::tOutTimer_Write_Switch_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffff7) | ((u32(fieldValue) << 0x3) & ~0xfffffff7);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Write_Switch_t tOutTimer::tMode_1_Register::getUI_Write_Switch(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Write_Switch_t((_softCopy & ~0xfffffff7) >> 0x3);
}

inline void tOutTimer::tMode_1_Register::writeUI_Write_Switch(nOutTimer::tOutTimer_Write_Switch_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setUI_Write_Switch(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimer_Write_Switch_t tOutTimer::tMode_1_Register::readUI_Write_Switch(nMDBG::tStatus2* s)
{
   return getUI_Write_Switch(s);
}

inline tOutTimer::tMode_1_Register& tOutTimer::tMode_1_Register::setUI_Reload_Mode(nOutTimer::tOutTimer_UI_Reload_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffff8f) | ((u32(fieldValue) << 0x4) & ~0xffffff8f);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_UI_Reload_Mode_t tOutTimer::tMode_1_Register::getUI_Reload_Mode(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_UI_Reload_Mode_t((_softCopy & ~0xffffff8f) >> 0x4);
}

inline void tOutTimer::tMode_1_Register::writeUI_Reload_Mode(nOutTimer::tOutTimer_UI_Reload_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setUI_Reload_Mode(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimer_UI_Reload_Mode_t tOutTimer::tMode_1_Register::readUI_Reload_Mode(nMDBG::tStatus2* s)
{
   return getUI_Reload_Mode(s);
}

inline tOutTimer::tMode_1_Register& tOutTimer::tMode_1_Register::setUI_Initial_Load_Source(nOutTimer::tOutTimer_Load_Source_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffff7f) | ((u32(fieldValue) << 0x7) & ~0xffffff7f);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Load_Source_t tOutTimer::tMode_1_Register::getUI_Initial_Load_Source(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Load_Source_t((_softCopy & ~0xffffff7f) >> 0x7);
}

inline void tOutTimer::tMode_1_Register::writeUI_Initial_Load_Source(nOutTimer::tOutTimer_Load_Source_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setUI_Initial_Load_Source(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimer_Load_Source_t tOutTimer::tMode_1_Register::readUI_Initial_Load_Source(nMDBG::tStatus2* s)
{
   return getUI_Initial_Load_Source(s);
}

inline tOutTimer::tMode_1_Register& tOutTimer::tMode_1_Register::setUC_Write_Switch(nOutTimer::tOutTimer_Write_Switch_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffbff) | ((u32(fieldValue) << 0xa) & ~0xfffffbff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Write_Switch_t tOutTimer::tMode_1_Register::getUC_Write_Switch(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Write_Switch_t((_softCopy & ~0xfffffbff) >> 0xa);
}

inline void tOutTimer::tMode_1_Register::writeUC_Write_Switch(nOutTimer::tOutTimer_Write_Switch_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setUC_Write_Switch(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimer_Write_Switch_t tOutTimer::tMode_1_Register::readUC_Write_Switch(nMDBG::tStatus2* s)
{
   return getUC_Write_Switch(s);
}

inline tOutTimer::tMode_1_Register& tOutTimer::tMode_1_Register::setUC_Initial_Load_Source(nOutTimer::tOutTimer_Load_Source_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffff7ff) | ((u32(fieldValue) << 0xb) & ~0xfffff7ff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Load_Source_t tOutTimer::tMode_1_Register::getUC_Initial_Load_Source(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Load_Source_t((_softCopy & ~0xfffff7ff) >> 0xb);
}

inline void tOutTimer::tMode_1_Register::writeUC_Initial_Load_Source(nOutTimer::tOutTimer_Load_Source_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setUC_Initial_Load_Source(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimer_Load_Source_t tOutTimer::tMode_1_Register::readUC_Initial_Load_Source(nMDBG::tStatus2* s)
{
   return getUC_Initial_Load_Source(s);
}

inline tOutTimer::tMode_1_Register& tOutTimer::tMode_1_Register::setFIFO_Retransmit_Enable(nOutTimer::tOutTimer_Disabled_Enabled_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffffdfff) | ((u32(fieldValue) << 0xd) & ~0xffffdfff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Disabled_Enabled_t tOutTimer::tMode_1_Register::getFIFO_Retransmit_Enable(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Disabled_Enabled_t((_softCopy & ~0xffffdfff) >> 0xd);
}

inline void tOutTimer::tMode_1_Register::writeFIFO_Retransmit_Enable(nOutTimer::tOutTimer_Disabled_Enabled_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setFIFO_Retransmit_Enable(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimer_Disabled_Enabled_t tOutTimer::tMode_1_Register::readFIFO_Retransmit_Enable(nMDBG::tStatus2* s)
{
   return getFIFO_Retransmit_Enable(s);
}

inline tOutTimer::tMode_1_Register& tOutTimer::tMode_1_Register::setFIFO_Mode(nOutTimer::tOutTimer_FIFO_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 nOutTimer::tOutTimer_FIFO_Mode_t tOutTimer::tMode_1_Register::getFIFO_Mode(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_FIFO_Mode_t((_softCopy & ~0xffff3fff) >> 0xe);
}

inline void tOutTimer::tMode_1_Register::writeFIFO_Mode(nOutTimer::tOutTimer_FIFO_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setFIFO_Mode(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimer_FIFO_Mode_t tOutTimer::tMode_1_Register::readFIFO_Mode(nMDBG::tStatus2* s)
{
   return getFIFO_Mode(s);
}

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

inline u32 tOutTimer::tMode_1_Register::getTrigger_Once(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xfffeffff) >> 0x10);
}

inline void tOutTimer::tMode_1_Register::writeTrigger_Once(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setTrigger_Once(fieldValue, s);
   flush(s, force);
}
inline u32 tOutTimer::tMode_1_Register::readTrigger_Once(nMDBG::tStatus2* s)
{
   return getTrigger_Once(s);
}

inline tOutTimer::tMode_1_Register& tOutTimer::tMode_1_Register::setContinuous(nOutTimer::tOutTimer_Continuous_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffdffff) | ((u32(fieldValue) << 0x11) & ~0xfffdffff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Continuous_t tOutTimer::tMode_1_Register::getContinuous(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Continuous_t((_softCopy & ~0xfffdffff) >> 0x11);
}

inline void tOutTimer::tMode_1_Register::writeContinuous(nOutTimer::tOutTimer_Continuous_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setContinuous(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimer_Continuous_t tOutTimer::tMode_1_Register::readContinuous(nMDBG::tStatus2* s)
{
   return getContinuous(s);
}

inline tOutTimer::tMode_1_Register& tOutTimer::tMode_1_Register::setUI_Source_Polarity(nOutTimer::tOutTimer_Polarity_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfff7ffff) | ((u32(fieldValue) << 0x13) & ~0xfff7ffff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Polarity_t tOutTimer::tMode_1_Register::getUI_Source_Polarity(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Polarity_t((_softCopy & ~0xfff7ffff) >> 0x13);
}

inline void tOutTimer::tMode_1_Register::writeUI_Source_Polarity(nOutTimer::tOutTimer_Polarity_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setUI_Source_Polarity(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimer_Polarity_t tOutTimer::tMode_1_Register::readUI_Source_Polarity(nMDBG::tStatus2* s)
{
   return getUI_Source_Polarity(s);
}

inline tOutTimer::tMode_1_Register& tOutTimer::tMode_1_Register::setUI_Source_Select(nOutTimer::tOutTimer_UI_Source_Select_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xf83fffff) | ((u32(fieldValue) << 0x16) & ~0xf83fffff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_UI_Source_Select_t tOutTimer::tMode_1_Register::getUI_Source_Select(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_UI_Source_Select_t((_softCopy & ~0xf83fffff) >> 0x16);
}

inline void tOutTimer::tMode_1_Register::writeUI_Source_Select(nOutTimer::tOutTimer_UI_Source_Select_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setUI_Source_Select(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimer_UI_Source_Select_t tOutTimer::tMode_1_Register::readUI_Source_Select(nMDBG::tStatus2* s)
{
   return getUI_Source_Select(s);
}

inline tOutTimer::tMode_1_Register& tOutTimer::tMode_1_Register::setUC_Reload_Mode(nOutTimer::tOutTimer_UC_Reload_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xe7ffffff) | ((u32(fieldValue) << 0x1b) & ~0xe7ffffff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_UC_Reload_Mode_t tOutTimer::tMode_1_Register::getUC_Reload_Mode(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_UC_Reload_Mode_t((_softCopy & ~0xe7ffffff) >> 0x1b);
}

inline void tOutTimer::tMode_1_Register::writeUC_Reload_Mode(nOutTimer::tOutTimer_UC_Reload_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setUC_Reload_Mode(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimer_UC_Reload_Mode_t tOutTimer::tMode_1_Register::readUC_Reload_Mode(nMDBG::tStatus2* s)
{
   return getUC_Reload_Mode(s);
}

inline tOutTimer::tMode_2_Register::tMode_2_Register()
{
   _softCopy = u32(0x0);
}

inline tOutTimer::tMode_2_Register::tRegisterMap* tOutTimer::tMode_2_Register::registerMap(void)
{
   return _regMap;
}

inline void tOutTimer::tMode_2_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u32 tOutTimer::tMode_2_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tOutTimer::tMode_2_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(0xfffbffff);
      _softCopy |= u32(0x0);
      markClean(s);
   }
}

inline void tOutTimer::tMode_2_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 tOutTimer::tMode_2_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tOutTimer::tMode_2_Register& tOutTimer::tMode_2_Register::setMute_A(nOutTimer::tOutTimer_Mute_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffffb) | ((u32(fieldValue) << 0x2) & ~0xfffffffb);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Mute_t tOutTimer::tMode_2_Register::getMute_A(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Mute_t((_softCopy & ~0xfffffffb) >> 0x2);
}

inline void tOutTimer::tMode_2_Register::writeMute_A(nOutTimer::tOutTimer_Mute_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setMute_A(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimer_Mute_t tOutTimer::tMode_2_Register::readMute_A(nMDBG::tStatus2* s)
{
   return getMute_A(s);
}

inline tOutTimer::tMode_2_Register& tOutTimer::tMode_2_Register::setMute_B(nOutTimer::tOutTimer_Mute_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffff7) | ((u32(fieldValue) << 0x3) & ~0xfffffff7);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Mute_t tOutTimer::tMode_2_Register::getMute_B(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Mute_t((_softCopy & ~0xfffffff7) >> 0x3);
}

inline void tOutTimer::tMode_2_Register::writeMute_B(nOutTimer::tOutTimer_Mute_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setMute_B(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimer_Mute_t tOutTimer::tMode_2_Register::readMute_B(nMDBG::tStatus2* s)
{
   return getMute_B(s);
}

inline tOutTimer::tMode_2_Register& tOutTimer::tMode_2_Register::setSyncMode(nOutTimer::tOutTimerSyncMode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffffe7f) | ((u32(fieldValue) << 0x7) & ~0xfffffe7f);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimerSyncMode_t tOutTimer::tMode_2_Register::getSyncMode(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimerSyncMode_t((_softCopy & ~0xfffffe7f) >> 0x7);
}

inline void tOutTimer::tMode_2_Register::writeSyncMode(nOutTimer::tOutTimerSyncMode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setSyncMode(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimerSyncMode_t tOutTimer::tMode_2_Register::readSyncMode(nMDBG::tStatus2* s)
{
   return getSyncMode(s);
}

inline tOutTimer::tMode_2_Register& tOutTimer::tMode_2_Register::setSoftware_Gate(nOutTimer::tOutTimer_Software_Gate_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffdffff) | ((u32(fieldValue) << 0x11) & ~0xfffdffff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Software_Gate_t tOutTimer::tMode_2_Register::getSoftware_Gate(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Software_Gate_t((_softCopy & ~0xfffdffff) >> 0x11);
}

inline void tOutTimer::tMode_2_Register::writeSoftware_Gate(nOutTimer::tOutTimer_Software_Gate_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setSoftware_Gate(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimer_Software_Gate_t tOutTimer::tMode_2_Register::readSoftware_Gate(nMDBG::tStatus2* s)
{
   return getSoftware_Gate(s);
}

inline tOutTimer::tMode_2_Register& tOutTimer::tMode_2_Register::setNot_An_UPDATE(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfffbffff) | ((u32(fieldValue) << 0x12) & ~0xfffbffff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tOutTimer::tMode_2_Register::getNot_An_UPDATE(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xfffbffff) >> 0x12);
}

inline void tOutTimer::tMode_2_Register::writeNot_An_UPDATE(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setNot_An_UPDATE(fieldValue, s);
   flush(s, force);
}
inline u32 tOutTimer::tMode_2_Register::readNot_An_UPDATE(nMDBG::tStatus2* s)
{
   return getNot_An_UPDATE(s);
}

inline tOutTimer::tMode_2_Register& tOutTimer::tMode_2_Register::setStop_On_BC_TC_Error(nOutTimer::tOutTimer_Stop_On_Error_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfff7ffff) | ((u32(fieldValue) << 0x13) & ~0xfff7ffff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Stop_On_Error_t tOutTimer::tMode_2_Register::getStop_On_BC_TC_Error(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Stop_On_Error_t((_softCopy & ~0xfff7ffff) >> 0x13);
}

inline void tOutTimer::tMode_2_Register::writeStop_On_BC_TC_Error(nOutTimer::tOutTimer_Stop_On_Error_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setStop_On_BC_TC_Error(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimer_Stop_On_Error_t tOutTimer::tMode_2_Register::readStop_On_BC_TC_Error(nMDBG::tStatus2* s)
{
   return getStop_On_BC_TC_Error(s);
}

inline tOutTimer::tMode_2_Register& tOutTimer::tMode_2_Register::setStop_On_BC_TC_Trigger_Error(nOutTimer::tOutTimer_Stop_On_Error_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffefffff) | ((u32(fieldValue) << 0x14) & ~0xffefffff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Stop_On_Error_t tOutTimer::tMode_2_Register::getStop_On_BC_TC_Trigger_Error(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Stop_On_Error_t((_softCopy & ~0xffefffff) >> 0x14);
}

inline void tOutTimer::tMode_2_Register::writeStop_On_BC_TC_Trigger_Error(nOutTimer::tOutTimer_Stop_On_Error_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setStop_On_BC_TC_Trigger_Error(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimer_Stop_On_Error_t tOutTimer::tMode_2_Register::readStop_On_BC_TC_Trigger_Error(nMDBG::tStatus2* s)
{
   return getStop_On_BC_TC_Trigger_Error(s);
}

inline tOutTimer::tMode_2_Register& tOutTimer::tMode_2_Register::setStop_On_Overrun_Error(nOutTimer::tOutTimer_Stop_On_Error_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffdfffff) | ((u32(fieldValue) << 0x15) & ~0xffdfffff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Stop_On_Error_t tOutTimer::tMode_2_Register::getStop_On_Overrun_Error(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Stop_On_Error_t((_softCopy & ~0xffdfffff) >> 0x15);
}

inline void tOutTimer::tMode_2_Register::writeStop_On_Overrun_Error(nOutTimer::tOutTimer_Stop_On_Error_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setStop_On_Overrun_Error(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimer_Stop_On_Error_t tOutTimer::tMode_2_Register::readStop_On_Overrun_Error(nMDBG::tStatus2* s)
{
   return getStop_On_Overrun_Error(s);
}

inline tOutTimer::tMode_2_Register& tOutTimer::tMode_2_Register::setAOFREQ_Enable(nOutTimer::tOutTimer_Disabled_Enabled_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xffbfffff) | ((u32(fieldValue) << 0x16) & ~0xffbfffff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Disabled_Enabled_t tOutTimer::tMode_2_Register::getAOFREQ_Enable(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Disabled_Enabled_t((_softCopy & ~0xffbfffff) >> 0x16);
}

inline void tOutTimer::tMode_2_Register::writeAOFREQ_Enable(nOutTimer::tOutTimer_Disabled_Enabled_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setAOFREQ_Enable(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimer_Disabled_Enabled_t tOutTimer::tMode_2_Register::readAOFREQ_Enable(nMDBG::tStatus2* s)
{
   return getAOFREQ_Enable(s);
}

inline tOutTimer::tMode_2_Register& tOutTimer::tMode_2_Register::setHold_BC_On_UC_Read(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xfbffffff) | ((u32(fieldValue) << 0x1a) & ~0xfbffffff);
   setRegister(newValue, s);
   return *this;
}

inline u32 tOutTimer::tMode_2_Register::getHold_BC_On_UC_Read(nMDBG::tStatus2*) const
{
   return u32((_softCopy & ~0xfbffffff) >> 0x1a);
}

inline void tOutTimer::tMode_2_Register::writeHold_BC_On_UC_Read(u32 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setHold_BC_On_UC_Read(fieldValue, s);
   flush(s, force);
}
inline u32 tOutTimer::tMode_2_Register::readHold_BC_On_UC_Read(nMDBG::tStatus2* s)
{
   return getHold_BC_On_UC_Read(s);
}

inline tOutTimer::tMode_2_Register& tOutTimer::tMode_2_Register::setStart1_Export_Mode(nOutTimer::tOutTimer_Start1_Export_Mode_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xf7ffffff) | ((u32(fieldValue) << 0x1b) & ~0xf7ffffff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Start1_Export_Mode_t tOutTimer::tMode_2_Register::getStart1_Export_Mode(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Start1_Export_Mode_t((_softCopy & ~0xf7ffffff) >> 0x1b);
}

inline void tOutTimer::tMode_2_Register::writeStart1_Export_Mode(nOutTimer::tOutTimer_Start1_Export_Mode_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setStart1_Export_Mode(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimer_Start1_Export_Mode_t tOutTimer::tMode_2_Register::readStart1_Export_Mode(nMDBG::tStatus2* s)
{
   return getStart1_Export_Mode(s);
}

inline tOutTimer::tMode_2_Register& tOutTimer::tMode_2_Register::setFIFO_Enable(nOutTimer::tOutTimer_Disabled_Enabled_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xdfffffff) | ((u32(fieldValue) << 0x1d) & ~0xdfffffff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Disabled_Enabled_t tOutTimer::tMode_2_Register::getFIFO_Enable(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Disabled_Enabled_t((_softCopy & ~0xdfffffff) >> 0x1d);
}

inline void tOutTimer::tMode_2_Register::writeFIFO_Enable(nOutTimer::tOutTimer_Disabled_Enabled_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setFIFO_Enable(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimer_Disabled_Enabled_t tOutTimer::tMode_2_Register::readFIFO_Enable(nMDBG::tStatus2* s)
{
   return getFIFO_Enable(s);
}

inline tOutTimer::tMode_2_Register& tOutTimer::tMode_2_Register::setBC_Gate_Enable(nOutTimer::tOutTimer_Disabled_Enabled_t fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u32 newValue;   newValue = (_softCopy & 0xbfffffff) | ((u32(fieldValue) << 0x1e) & ~0xbfffffff);
   setRegister(newValue, s);
   return *this;
}

inline nOutTimer::tOutTimer_Disabled_Enabled_t tOutTimer::tMode_2_Register::getBC_Gate_Enable(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Disabled_Enabled_t((_softCopy & ~0xbfffffff) >> 0x1e);
}

inline void tOutTimer::tMode_2_Register::writeBC_Gate_Enable(nOutTimer::tOutTimer_Disabled_Enabled_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setBC_Gate_Enable(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimer_Disabled_Enabled_t tOutTimer::tMode_2_Register::readBC_Gate_Enable(nMDBG::tStatus2* s)
{
   return getBC_Gate_Enable(s);
}

inline tOutTimer::tOutput_Control_Register::tOutput_Control_Register()
{
   _softCopy = u16(0x0);
}

inline tOutTimer::tOutput_Control_Register::tRegisterMap* tOutTimer::tOutput_Control_Register::registerMap(void)
{
   return _regMap;
}

inline void tOutTimer::tOutput_Control_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

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

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

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

inline u16 tOutTimer::tOutput_Control_Register::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

inline void tOutTimer::tOutput_Control_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 tOutTimer::tOutput_Control_Register::readRegister(nMDBG::tStatus2*)
{
   return _softCopy;
}


inline tOutTimer::tOutput_Control_Register& tOutTimer::tOutput_Control_Register::setExportedUpdatePolarity(nOutTimer::tOutTimer_Polarity_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 nOutTimer::tOutTimer_Polarity_t tOutTimer::tOutput_Control_Register::getExportedUpdatePolarity(nMDBG::tStatus2*) const
{
   return nOutTimer::tOutTimer_Polarity_t((_softCopy & ~0xfffe) >> 0x0);
}

inline void tOutTimer::tOutput_Control_Register::writeExportedUpdatePolarity(nOutTimer::tOutTimer_Polarity_t fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setExportedUpdatePolarity(fieldValue, s);
   flush(s, force);
}
inline nOutTimer::tOutTimer_Polarity_t tOutTimer::tOutput_Control_Register::readExportedUpdatePolarity(nMDBG::tStatus2* s)
{
   return getExportedUpdatePolarity(s);
}

inline tOutTimer::tOutput_Control_Register& tOutTimer::tOutput_Control_Register::setNumber_Of_Channels(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = (_softCopy & 0xff) | ((u16(fieldValue) << 0x8) & ~0xff);
   setRegister(newValue, s);
   return *this;
}

inline u16 tOutTimer::tOutput_Control_Register::getNumber_Of_Channels(nMDBG::tStatus2*) const
{
   return u16((_softCopy & ~0xff) >> 0x8);
}

inline void tOutTimer::tOutput_Control_Register::writeNumber_Of_Channels(u16 fieldValue, nMDBG::tStatus2* s, tBoolean force)
{
   setNumber_Of_Channels(fieldValue, s);
   flush(s, force);
}
inline u16 tOutTimer::tOutput_Control_Register::readNumber_Of_Channels(nMDBG::tStatus2* s)
{
   return getNumber_Of_Channels(s);
}

inline tOutTimer::tInterrupt1_Register::tInterrupt1_Register()
{
}

inline tOutTimer::tInterrupt1_Register::tRegisterMap* tOutTimer::tInterrupt1_Register::registerMap(void)
{
   return _regMap;
}

inline void tOutTimer::tInterrupt1_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline void tOutTimer::tInterrupt1_Register::writeBC_TC_Interrupt_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x0) & ~0xfffffffe,s);
}
inline void tOutTimer::tInterrupt1_Register::writeSTART1_Interrupt_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x1) & ~0xfffffffd,s);
}
inline void tOutTimer::tInterrupt1_Register::writeUPDATE_Interrupt_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x2) & ~0xfffffffb,s);
}
inline void tOutTimer::tInterrupt1_Register::writeError_Interrupt_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x5) & ~0xffffffdf,s);
}
inline void tOutTimer::tInterrupt1_Register::writeUC_TC_Interrupt_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x6) & ~0xffffffbf,s);
}
inline void tOutTimer::tInterrupt1_Register::writeFIFO_Interrupt_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x8) & ~0xfffffeff,s);
}
inline void tOutTimer::tInterrupt1_Register::writeWrite_Too_Fast_Interrupt_Enable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x9) & ~0xfffffdff,s);
}
inline void tOutTimer::tInterrupt1_Register::writeWrite_Too_Fast_Interrupt_Ack(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x10) & ~0xfffeffff,s);
}
inline void tOutTimer::tInterrupt1_Register::writeBC_TC_Trigger_Error_Confirm(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x13) & ~0xfff7ffff,s);
}
inline void tOutTimer::tInterrupt1_Register::writeBC_TC_Error_Confirm(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x14) & ~0xffefffff,s);
}
inline void tOutTimer::tInterrupt1_Register::writeUC_TC_Interrupt_Ack(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x17) & ~0xff7fffff,s);
}
inline void tOutTimer::tInterrupt1_Register::writeBC_TC_Interrupt_Ack(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x18) & ~0xfeffffff,s);
}
inline void tOutTimer::tInterrupt1_Register::writeSTART1_Interrupt_Ack(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x19) & ~0xfdffffff,s);
}
inline void tOutTimer::tInterrupt1_Register::writeUPDATE_Interrupt_Ack(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x1a) & ~0xfbffffff,s);
}
inline void tOutTimer::tInterrupt1_Register::writeError_Interrupt_Ack(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x1d) & ~0xdfffffff,s);
}
inline tOutTimer::tInterrupt2_Register::tInterrupt2_Register()
{
}

inline tOutTimer::tInterrupt2_Register::tRegisterMap* tOutTimer::tInterrupt2_Register::registerMap(void)
{
   return _regMap;
}

inline void tOutTimer::tInterrupt2_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline void tOutTimer::tInterrupt2_Register::writeBC_TC_Interrupt_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x0) & ~0xfffffffe,s);
}
inline void tOutTimer::tInterrupt2_Register::writeSTART1_Interrupt_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x1) & ~0xfffffffd,s);
}
inline void tOutTimer::tInterrupt2_Register::writeUPDATE_Interrupt_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x2) & ~0xfffffffb,s);
}
inline void tOutTimer::tInterrupt2_Register::writeError_Interrupt_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x5) & ~0xffffffdf,s);
}
inline void tOutTimer::tInterrupt2_Register::writeUC_TC_Interrupt_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x6) & ~0xffffffbf,s);
}
inline void tOutTimer::tInterrupt2_Register::writeFIFO_Interrupt_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x8) & ~0xfffffeff,s);
}
inline void tOutTimer::tInterrupt2_Register::writeWrite_Too_Fast_Interrupt_Disable(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x9) & ~0xfffffdff,s);
}
inline void tOutTimer::tInterrupt2_Register::writeWrite_Too_Fast_Interrupt_Ack2(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x10) & ~0xfffeffff,s);
}
inline void tOutTimer::tInterrupt2_Register::writeBC_TC_Trigger_Error_Confirm2(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x13) & ~0xfff7ffff,s);
}
inline void tOutTimer::tInterrupt2_Register::writeBC_TC_Error_Confirm2(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x14) & ~0xffefffff,s);
}
inline void tOutTimer::tInterrupt2_Register::writeUC_TC_Interrupt_Ack2(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x17) & ~0xff7fffff,s);
}
inline void tOutTimer::tInterrupt2_Register::writeBC_TC_Interrupt_Ack2(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x18) & ~0xfeffffff,s);
}
inline void tOutTimer::tInterrupt2_Register::writeSTART1_Interrupt_Ack2(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x19) & ~0xfdffffff,s);
}
inline void tOutTimer::tInterrupt2_Register::writeUPDATE_Interrupt_Ack2(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x1a) & ~0xfbffffff,s);
}
inline void tOutTimer::tInterrupt2_Register::writeError_Interrupt_Ack2(u32 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u32(fieldValue) << 0x1d) & ~0xdfffffff,s);
}
inline tOutTimer::tReset_Register::tReset_Register()
{
}

inline tOutTimer::tReset_Register::tRegisterMap* tOutTimer::tReset_Register::registerMap(void)
{
   return _regMap;
}

inline void tOutTimer::tReset_Register::setRegisterMap(tRegisterMap* pRegMap)
{
   _regMap = pRegMap;
}

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

inline void tOutTimer::tReset_Register::writeReset(u16 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u16(fieldValue) << 0x0) & ~0xfffe,s);
}
inline void tOutTimer::tReset_Register::writeConfiguration_Start(u16 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u16(fieldValue) << 0x1) & ~0xfffd,s);
}
inline void tOutTimer::tReset_Register::writeConfiguration_End(u16 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u16(fieldValue) << 0x2) & ~0xfffb,s);
}
inline void tOutTimer::tReset_Register::writeFIFO_Clear(u16 fieldValue, nMDBG::tStatus2* s)
{
   writeRegister((u16(fieldValue) << 0x3) & ~0xfff7,s);
}
#endif


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