plugins/ni_device/tMSeries_auto.cpp

Go to the documentation of this file.

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

#ifndef ___tMSeries_ipp___
#define ___tMSeries_ipp___

#ifndef ___tMSeries_h___
#include "tMSeries.h"
#endif

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

inline void tMSeries::tReg16IODirect32::write(
   tBusSpaceReference addrSpace,
   u32 offset,
   u16 value,
   nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   addrSpace.write16(offset, u16(value));
}

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

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

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

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

inline void tMSeries::setAddressOffset(u32 value, nMDBG::tStatus2* s)
{
   _addressOffset = value;
}
inline u32  tMSeries::getAddressOffset(nMDBG::tStatus2* s)
{
   return _addressOffset;
}
inline void tMSeries::flushBus(nMDBG::tStatus2* s)
{

}

inline tMSeries::tAI_Command_1::tAI_Command_1()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAI_Command_1::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAI_Command_1::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u16 tMSeries::tAI_Command_1::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAI_Command_1::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u16)(0xffff0000);
}

inline void tMSeries::tAI_Command_1::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u16 tMSeries::tAI_Command_1::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


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

inline u16 tMSeries::tAI_Command_1::getAI_CONVERT_Pulse(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfffe) >> 0x0);
}

inline void tMSeries::tAI_Command_1::writeAI_CONVERT_Pulse(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_CONVERT_Pulse(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_1::readAI_CONVERT_Pulse(nMDBG::tStatus2* s)
{
   return getAI_CONVERT_Pulse(s);
}

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

inline u16 tMSeries::tAI_Command_1::getAI_LOCALMUX_CLK_Pulse(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfffb) >> 0x2);
}

inline void tMSeries::tAI_Command_1::writeAI_LOCALMUX_CLK_Pulse(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_LOCALMUX_CLK_Pulse(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_1::readAI_LOCALMUX_CLK_Pulse(nMDBG::tStatus2* s)
{
   return getAI_LOCALMUX_CLK_Pulse(s);
}

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

inline u16 tMSeries::tAI_Command_1::getAI_EXTMUX_CLK_Pulse(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfff7) >> 0x3);
}

inline void tMSeries::tAI_Command_1::writeAI_EXTMUX_CLK_Pulse(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_EXTMUX_CLK_Pulse(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_1::readAI_EXTMUX_CLK_Pulse(nMDBG::tStatus2* s)
{
   return getAI_EXTMUX_CLK_Pulse(s);
}

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

inline u16 tMSeries::tAI_Command_1::getAI_SCAN_IN_PROG_Pulse(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xffef) >> 0x4);
}

inline void tMSeries::tAI_Command_1::writeAI_SCAN_IN_PROG_Pulse(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_SCAN_IN_PROG_Pulse(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_1::readAI_SCAN_IN_PROG_Pulse(nMDBG::tStatus2* s)
{
   return getAI_SCAN_IN_PROG_Pulse(s);
}

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

inline u16 tMSeries::tAI_Command_1::getAI_SC_Load(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xffdf) >> 0x5);
}

inline void tMSeries::tAI_Command_1::writeAI_SC_Load(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_SC_Load(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_1::readAI_SC_Load(nMDBG::tStatus2* s)
{
   return getAI_SC_Load(s);
}

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

inline u16 tMSeries::tAI_Command_1::getAI_SC_Arm(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xffbf) >> 0x6);
}

inline void tMSeries::tAI_Command_1::writeAI_SC_Arm(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_SC_Arm(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_1::readAI_SC_Arm(nMDBG::tStatus2* s)
{
   return getAI_SC_Arm(s);
}

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

inline u16 tMSeries::tAI_Command_1::getAI_DIV_Load(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xff7f) >> 0x7);
}

inline void tMSeries::tAI_Command_1::writeAI_DIV_Load(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_DIV_Load(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_1::readAI_DIV_Load(nMDBG::tStatus2* s)
{
   return getAI_DIV_Load(s);
}

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

inline u16 tMSeries::tAI_Command_1::getAI_DIV_Arm(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfeff) >> 0x8);
}

inline void tMSeries::tAI_Command_1::writeAI_DIV_Arm(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_DIV_Arm(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_1::readAI_DIV_Arm(nMDBG::tStatus2* s)
{
   return getAI_DIV_Arm(s);
}

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

inline u16 tMSeries::tAI_Command_1::getAI_SI_Load(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfdff) >> 0x9);
}

inline void tMSeries::tAI_Command_1::writeAI_SI_Load(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_SI_Load(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_1::readAI_SI_Load(nMDBG::tStatus2* s)
{
   return getAI_SI_Load(s);
}

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

inline u16 tMSeries::tAI_Command_1::getAI_SI_Arm(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfbff) >> 0xa);
}

inline void tMSeries::tAI_Command_1::writeAI_SI_Arm(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_SI_Arm(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_1::readAI_SI_Arm(nMDBG::tStatus2* s)
{
   return getAI_SI_Arm(s);
}

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

inline u16 tMSeries::tAI_Command_1::getAI_SI2_Load(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xf7ff) >> 0xb);
}

inline void tMSeries::tAI_Command_1::writeAI_SI2_Load(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_SI2_Load(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_1::readAI_SI2_Load(nMDBG::tStatus2* s)
{
   return getAI_SI2_Load(s);
}

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

inline u16 tMSeries::tAI_Command_1::getAI_SI2_Arm(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xefff) >> 0xc);
}

inline void tMSeries::tAI_Command_1::writeAI_SI2_Arm(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_SI2_Arm(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_1::readAI_SI2_Arm(nMDBG::tStatus2* s)
{
   return getAI_SI2_Arm(s);
}

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

inline u16 tMSeries::tAI_Command_1::getAI_Disarm(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xdfff) >> 0xd);
}

inline void tMSeries::tAI_Command_1::writeAI_Disarm(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_Disarm(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_1::readAI_Disarm(nMDBG::tStatus2* s)
{
   return getAI_Disarm(s);
}

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

inline u16 tMSeries::tAI_Command_1::getAI_Analog_Trigger_Reset(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xbfff) >> 0xe);
}

inline void tMSeries::tAI_Command_1::writeAI_Analog_Trigger_Reset(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_Analog_Trigger_Reset(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_1::readAI_Analog_Trigger_Reset(nMDBG::tStatus2* s)
{
   return getAI_Analog_Trigger_Reset(s);
}

inline void tMSeries::tAI_Command_1::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAI_Command_2::tAI_Command_2()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAI_Command_2::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAI_Command_2::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u16 tMSeries::tAI_Command_2::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAI_Command_2::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u16)(0xffff3c00);
}

inline void tMSeries::tAI_Command_2::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u16 tMSeries::tAI_Command_2::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


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

inline u16 tMSeries::tAI_Command_2::getAI_START1_Pulse(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfffe) >> 0x0);
}

inline void tMSeries::tAI_Command_2::writeAI_START1_Pulse(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_START1_Pulse(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_2::readAI_START1_Pulse(nMDBG::tStatus2* s)
{
   return getAI_START1_Pulse(s);
}

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

inline u16 tMSeries::tAI_Command_2::getAI_START2_Pulse(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfffd) >> 0x1);
}

inline void tMSeries::tAI_Command_2::writeAI_START2_Pulse(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_START2_Pulse(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_2::readAI_START2_Pulse(nMDBG::tStatus2* s)
{
   return getAI_START2_Pulse(s);
}

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

inline u16 tMSeries::tAI_Command_2::getAI_START_Pulse(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfffb) >> 0x2);
}

inline void tMSeries::tAI_Command_2::writeAI_START_Pulse(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_START_Pulse(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_2::readAI_START_Pulse(nMDBG::tStatus2* s)
{
   return getAI_START_Pulse(s);
}

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

inline u16 tMSeries::tAI_Command_2::getAI_STOP_Pulse(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfff7) >> 0x3);
}

inline void tMSeries::tAI_Command_2::writeAI_STOP_Pulse(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_STOP_Pulse(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_2::readAI_STOP_Pulse(nMDBG::tStatus2* s)
{
   return getAI_STOP_Pulse(s);
}

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

inline u16 tMSeries::tAI_Command_2::getAI_SC_Switch_Load_On_TC(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xffef) >> 0x4);
}

inline void tMSeries::tAI_Command_2::writeAI_SC_Switch_Load_On_TC(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_SC_Switch_Load_On_TC(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_2::readAI_SC_Switch_Load_On_TC(nMDBG::tStatus2* s)
{
   return getAI_SC_Switch_Load_On_TC(s);
}

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

inline u16 tMSeries::tAI_Command_2::getAI_SI_Switch_Load_On_TC(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xff7f) >> 0x7);
}

inline void tMSeries::tAI_Command_2::writeAI_SI_Switch_Load_On_TC(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_SI_Switch_Load_On_TC(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_2::readAI_SI_Switch_Load_On_TC(nMDBG::tStatus2* s)
{
   return getAI_SI_Switch_Load_On_TC(s);
}

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

inline u16 tMSeries::tAI_Command_2::getAI_SI_Switch_Load_On_STOP(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfeff) >> 0x8);
}

inline void tMSeries::tAI_Command_2::writeAI_SI_Switch_Load_On_STOP(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_SI_Switch_Load_On_STOP(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_2::readAI_SI_Switch_Load_On_STOP(nMDBG::tStatus2* s)
{
   return getAI_SI_Switch_Load_On_STOP(s);
}

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

inline u16 tMSeries::tAI_Command_2::getAI_SI_Switch_Load_On_SC_TC(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfdff) >> 0x9);
}

inline void tMSeries::tAI_Command_2::writeAI_SI_Switch_Load_On_SC_TC(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_SI_Switch_Load_On_SC_TC(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_2::readAI_SI_Switch_Load_On_SC_TC(nMDBG::tStatus2* s)
{
   return getAI_SI_Switch_Load_On_SC_TC(s);
}

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

inline u16 tMSeries::tAI_Command_2::getAI_SC_Save_Trace(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfbff) >> 0xa);
}

inline void tMSeries::tAI_Command_2::writeAI_SC_Save_Trace(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_SC_Save_Trace(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_2::readAI_SC_Save_Trace(nMDBG::tStatus2* s)
{
   return getAI_SC_Save_Trace(s);
}

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

inline u16 tMSeries::tAI_Command_2::getAI_START1_Disable(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xf7ff) >> 0xb);
}

inline void tMSeries::tAI_Command_2::writeAI_START1_Disable(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_START1_Disable(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_2::readAI_START1_Disable(nMDBG::tStatus2* s)
{
   return getAI_START1_Disable(s);
}

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

inline u16 tMSeries::tAI_Command_2::getAI_End_On_End_Of_Scan(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xbfff) >> 0xe);
}

inline void tMSeries::tAI_Command_2::writeAI_End_On_End_Of_Scan(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_End_On_End_Of_Scan(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_2::readAI_End_On_End_Of_Scan(nMDBG::tStatus2* s)
{
   return getAI_End_On_End_Of_Scan(s);
}

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

inline u16 tMSeries::tAI_Command_2::getAI_End_On_SC_TC(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0x7fff) >> 0xf);
}

inline void tMSeries::tAI_Command_2::writeAI_End_On_SC_TC(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_End_On_SC_TC(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Command_2::readAI_End_On_SC_TC(nMDBG::tStatus2* s)
{
   return getAI_End_On_SC_TC(s);
}

inline void tMSeries::tAI_Command_2::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAI_Mode_2::tAI_Mode_2()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAI_Mode_2::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAI_Mode_2::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u16 tMSeries::tAI_Mode_2::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAI_Mode_2::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u16)(0xffffffff);
}

inline void tMSeries::tAI_Mode_2::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u16 tMSeries::tAI_Mode_2::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


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

inline u16 tMSeries::tAI_Mode_2::getAI_SC_Write_Switch(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfffe) >> 0x0);
}

inline void tMSeries::tAI_Mode_2::writeAI_SC_Write_Switch(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_SC_Write_Switch(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Mode_2::readAI_SC_Write_Switch(nMDBG::tStatus2* s)
{
   return getAI_SC_Write_Switch(s);
}

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

inline tMSeries::tAI_Mode_2::tAI_SC_Reload_Mode tMSeries::tAI_Mode_2::getAI_SC_Reload_Mode(nMDBG::tStatus2*) const
{
   return (tAI_SC_Reload_Mode)((_softCopy & ~0xfffd) >> 0x1);
}

inline void tMSeries::tAI_Mode_2::writeAI_SC_Reload_Mode(tAI_SC_Reload_Mode fieldValue, nMDBG::tStatus2* s)
{
   setAI_SC_Reload_Mode(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_Mode_2::tAI_SC_Reload_Mode tMSeries::tAI_Mode_2::readAI_SC_Reload_Mode(nMDBG::tStatus2* s)
{
   return getAI_SC_Reload_Mode(s);
}

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

inline tMSeries::tAI_Mode_2::tAI_SC_Initial_Load_Source tMSeries::tAI_Mode_2::getAI_SC_Initial_Load_Source(nMDBG::tStatus2*) const
{
   return (tAI_SC_Initial_Load_Source)((_softCopy & ~0xfffb) >> 0x2);
}

inline void tMSeries::tAI_Mode_2::writeAI_SC_Initial_Load_Source(tAI_SC_Initial_Load_Source fieldValue, nMDBG::tStatus2* s)
{
   setAI_SC_Initial_Load_Source(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_Mode_2::tAI_SC_Initial_Load_Source tMSeries::tAI_Mode_2::readAI_SC_Initial_Load_Source(nMDBG::tStatus2* s)
{
   return getAI_SC_Initial_Load_Source(s);
}

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

inline u16 tMSeries::tAI_Mode_2::getAI_SI_Write_Switch(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfff7) >> 0x3);
}

inline void tMSeries::tAI_Mode_2::writeAI_SI_Write_Switch(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_SI_Write_Switch(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Mode_2::readAI_SI_Write_Switch(nMDBG::tStatus2* s)
{
   return getAI_SI_Write_Switch(s);
}

inline tMSeries::tAI_Mode_2& tMSeries::tAI_Mode_2::setAI_SI_Reload_Mode(tAI_SI_Reload_Mode fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = ((u16)(_softCopy & 0xff8f)) | (((u16)fieldValue << 0x4) & ~0xff8f);
   setRegister(newValue, s);
   return *this;
}

inline tMSeries::tAI_Mode_2::tAI_SI_Reload_Mode tMSeries::tAI_Mode_2::getAI_SI_Reload_Mode(nMDBG::tStatus2*) const
{
   return (tAI_SI_Reload_Mode)((_softCopy & ~0xff8f) >> 0x4);
}

inline void tMSeries::tAI_Mode_2::writeAI_SI_Reload_Mode(tAI_SI_Reload_Mode fieldValue, nMDBG::tStatus2* s)
{
   setAI_SI_Reload_Mode(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_Mode_2::tAI_SI_Reload_Mode tMSeries::tAI_Mode_2::readAI_SI_Reload_Mode(nMDBG::tStatus2* s)
{
   return getAI_SI_Reload_Mode(s);
}

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

inline tMSeries::tAI_Mode_2::tAI_SI_Initial_Load_Source tMSeries::tAI_Mode_2::getAI_SI_Initial_Load_Source(nMDBG::tStatus2*) const
{
   return (tAI_SI_Initial_Load_Source)((_softCopy & ~0xff7f) >> 0x7);
}

inline void tMSeries::tAI_Mode_2::writeAI_SI_Initial_Load_Source(tAI_SI_Initial_Load_Source fieldValue, nMDBG::tStatus2* s)
{
   setAI_SI_Initial_Load_Source(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_Mode_2::tAI_SI_Initial_Load_Source tMSeries::tAI_Mode_2::readAI_SI_Initial_Load_Source(nMDBG::tStatus2* s)
{
   return getAI_SI_Initial_Load_Source(s);
}

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

inline tMSeries::tAI_Mode_2::tAI_SI2_Reload_Mode tMSeries::tAI_Mode_2::getAI_SI2_Reload_Mode(nMDBG::tStatus2*) const
{
   return (tAI_SI2_Reload_Mode)((_softCopy & ~0xfeff) >> 0x8);
}

inline void tMSeries::tAI_Mode_2::writeAI_SI2_Reload_Mode(tAI_SI2_Reload_Mode fieldValue, nMDBG::tStatus2* s)
{
   setAI_SI2_Reload_Mode(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_Mode_2::tAI_SI2_Reload_Mode tMSeries::tAI_Mode_2::readAI_SI2_Reload_Mode(nMDBG::tStatus2* s)
{
   return getAI_SI2_Reload_Mode(s);
}

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

inline tMSeries::tAI_Mode_2::tAI_SI2_Initial_Load_Source tMSeries::tAI_Mode_2::getAI_SI2_Initial_Load_Source(nMDBG::tStatus2*) const
{
   return (tAI_SI2_Initial_Load_Source)((_softCopy & ~0xfdff) >> 0x9);
}

inline void tMSeries::tAI_Mode_2::writeAI_SI2_Initial_Load_Source(tAI_SI2_Initial_Load_Source fieldValue, nMDBG::tStatus2* s)
{
   setAI_SI2_Initial_Load_Source(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_Mode_2::tAI_SI2_Initial_Load_Source tMSeries::tAI_Mode_2::readAI_SI2_Initial_Load_Source(nMDBG::tStatus2* s)
{
   return getAI_SI2_Initial_Load_Source(s);
}

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

inline tMSeries::tAI_Mode_2::tAI_External_MUX_Present tMSeries::tAI_Mode_2::getAI_External_MUX_Present(nMDBG::tStatus2*) const
{
   return (tAI_External_MUX_Present)((_softCopy & ~0xefff) >> 0xc);
}

inline void tMSeries::tAI_Mode_2::writeAI_External_MUX_Present(tAI_External_MUX_Present fieldValue, nMDBG::tStatus2* s)
{
   setAI_External_MUX_Present(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_Mode_2::tAI_External_MUX_Present tMSeries::tAI_Mode_2::readAI_External_MUX_Present(nMDBG::tStatus2* s)
{
   return getAI_External_MUX_Present(s);
}

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

inline tBoolean tMSeries::tAI_Mode_2::getAI_Pre_Trigger(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xdfff) >> 0xd);
}

inline void tMSeries::tAI_Mode_2::writeAI_Pre_Trigger(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAI_Pre_Trigger(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAI_Mode_2::readAI_Pre_Trigger(nMDBG::tStatus2* s)
{
   return getAI_Pre_Trigger(s);
}

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

inline tBoolean tMSeries::tAI_Mode_2::getAI_Start_Stop_Gate_Enable(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xbfff) >> 0xe);
}

inline void tMSeries::tAI_Mode_2::writeAI_Start_Stop_Gate_Enable(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAI_Start_Stop_Gate_Enable(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAI_Mode_2::readAI_Start_Stop_Gate_Enable(nMDBG::tStatus2* s)
{
   return getAI_Start_Stop_Gate_Enable(s);
}

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

inline tBoolean tMSeries::tAI_Mode_2::getAI_SC_Gate_Enable(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0x7fff) >> 0xf);
}

inline void tMSeries::tAI_Mode_2::writeAI_SC_Gate_Enable(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAI_SC_Gate_Enable(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAI_Mode_2::readAI_SC_Gate_Enable(nMDBG::tStatus2* s)
{
   return getAI_SC_Gate_Enable(s);
}

inline void tMSeries::tAI_Mode_2::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAI_Mode_3::tAI_Mode_3()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAI_Mode_3::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAI_Mode_3::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u16 tMSeries::tAI_Mode_3::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAI_Mode_3::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u16)(0xffffffff);
}

inline void tMSeries::tAI_Mode_3::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u16 tMSeries::tAI_Mode_3::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


inline tMSeries::tAI_Mode_3& tMSeries::tAI_Mode_3::setAI_External_Gate_Select(tAI_External_Gate_Select fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = ((u16)(_softCopy & 0xffe0)) | (((u16)fieldValue << 0x0) & ~0xffe0);
   setRegister(newValue, s);
   return *this;
}

inline tMSeries::tAI_Mode_3::tAI_External_Gate_Select tMSeries::tAI_Mode_3::getAI_External_Gate_Select(nMDBG::tStatus2*) const
{
   return (tAI_External_Gate_Select)((_softCopy & ~0xffe0) >> 0x0);
}

inline void tMSeries::tAI_Mode_3::writeAI_External_Gate_Select(tAI_External_Gate_Select fieldValue, nMDBG::tStatus2* s)
{
   setAI_External_Gate_Select(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_Mode_3::tAI_External_Gate_Select tMSeries::tAI_Mode_3::readAI_External_Gate_Select(nMDBG::tStatus2* s)
{
   return getAI_External_Gate_Select(s);
}

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

inline tMSeries::tAI_Mode_3::tAI_External_Gate_Polarity tMSeries::tAI_Mode_3::getAI_External_Gate_Polarity(nMDBG::tStatus2*) const
{
   return (tAI_External_Gate_Polarity)((_softCopy & ~0xffdf) >> 0x5);
}

inline void tMSeries::tAI_Mode_3::writeAI_External_Gate_Polarity(tAI_External_Gate_Polarity fieldValue, nMDBG::tStatus2* s)
{
   setAI_External_Gate_Polarity(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_Mode_3::tAI_External_Gate_Polarity tMSeries::tAI_Mode_3::readAI_External_Gate_Polarity(nMDBG::tStatus2* s)
{
   return getAI_External_Gate_Polarity(s);
}

inline tMSeries::tAI_Mode_3& tMSeries::tAI_Mode_3::setAI_FIFO_Mode(tAI_FIFO_Mode fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = ((u16)(_softCopy & 0xff3f)) | (((u16)fieldValue << 0x6) & ~0xff3f);
   setRegister(newValue, s);
   return *this;
}

inline tMSeries::tAI_Mode_3::tAI_FIFO_Mode tMSeries::tAI_Mode_3::getAI_FIFO_Mode(nMDBG::tStatus2*) const
{
   return (tAI_FIFO_Mode)((_softCopy & ~0xff3f) >> 0x6);
}

inline void tMSeries::tAI_Mode_3::writeAI_FIFO_Mode(tAI_FIFO_Mode fieldValue, nMDBG::tStatus2* s)
{
   setAI_FIFO_Mode(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_Mode_3::tAI_FIFO_Mode tMSeries::tAI_Mode_3::readAI_FIFO_Mode(nMDBG::tStatus2* s)
{
   return getAI_FIFO_Mode(s);
}

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

inline tMSeries::tAI_Mode_3::tAI_External_Gate_Mode tMSeries::tAI_Mode_3::getAI_External_Gate_Mode(nMDBG::tStatus2*) const
{
   return (tAI_External_Gate_Mode)((_softCopy & ~0xfeff) >> 0x8);
}

inline void tMSeries::tAI_Mode_3::writeAI_External_Gate_Mode(tAI_External_Gate_Mode fieldValue, nMDBG::tStatus2* s)
{
   setAI_External_Gate_Mode(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_Mode_3::tAI_External_Gate_Mode tMSeries::tAI_Mode_3::readAI_External_Gate_Mode(nMDBG::tStatus2* s)
{
   return getAI_External_Gate_Mode(s);
}

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

inline tBoolean tMSeries::tAI_Mode_3::getAI_Delayed_START1(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xfdff) >> 0x9);
}

inline void tMSeries::tAI_Mode_3::writeAI_Delayed_START1(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAI_Delayed_START1(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAI_Mode_3::readAI_Delayed_START1(nMDBG::tStatus2* s)
{
   return getAI_Delayed_START1(s);
}

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

inline tBoolean tMSeries::tAI_Mode_3::getAI_Delayed_START2(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xfbff) >> 0xa);
}

inline void tMSeries::tAI_Mode_3::writeAI_Delayed_START2(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAI_Delayed_START2(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAI_Mode_3::readAI_Delayed_START2(nMDBG::tStatus2* s)
{
   return getAI_Delayed_START2(s);
}

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

inline tMSeries::tAI_Mode_3::tAI_SI2_Source_Select tMSeries::tAI_Mode_3::getAI_SI2_Source_Select(nMDBG::tStatus2*) const
{
   return (tAI_SI2_Source_Select)((_softCopy & ~0xf7ff) >> 0xb);
}

inline void tMSeries::tAI_Mode_3::writeAI_SI2_Source_Select(tAI_SI2_Source_Select fieldValue, nMDBG::tStatus2* s)
{
   setAI_SI2_Source_Select(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_Mode_3::tAI_SI2_Source_Select tMSeries::tAI_Mode_3::readAI_SI2_Source_Select(nMDBG::tStatus2* s)
{
   return getAI_SI2_Source_Select(s);
}

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

inline u16 tMSeries::tAI_Mode_3::getAI_Software_Gate(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xdfff) >> 0xd);
}

inline void tMSeries::tAI_Mode_3::writeAI_Software_Gate(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_Software_Gate(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Mode_3::readAI_Software_Gate(nMDBG::tStatus2* s)
{
   return getAI_Software_Gate(s);
}

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

inline u16 tMSeries::tAI_Mode_3::getAI_Delay_START(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xbfff) >> 0xe);
}

inline void tMSeries::tAI_Mode_3::writeAI_Delay_START(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_Delay_START(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Mode_3::readAI_Delay_START(nMDBG::tStatus2* s)
{
   return getAI_Delay_START(s);
}

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

inline u16 tMSeries::tAI_Mode_3::getAI_Trigger_Length(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0x7fff) >> 0xf);
}

inline void tMSeries::tAI_Mode_3::writeAI_Trigger_Length(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAI_Trigger_Length(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAI_Mode_3::readAI_Trigger_Length(nMDBG::tStatus2* s)
{
   return getAI_Trigger_Length(s);
}

inline void tMSeries::tAI_Mode_3::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAI_Personal::tAI_Personal()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAI_Personal::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAI_Personal::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u16 tMSeries::tAI_Personal::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAI_Personal::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u16)(0xffffffff);
}

inline void tMSeries::tAI_Personal::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u16 tMSeries::tAI_Personal::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


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

inline tMSeries::tAI_Personal::tAI_EXTMUX_CLK_Pulse_Width tMSeries::tAI_Personal::getAI_EXTMUX_CLK_Pulse_Width(nMDBG::tStatus2*) const
{
   return (tAI_EXTMUX_CLK_Pulse_Width)((_softCopy & ~0xffbf) >> 0x6);
}

inline void tMSeries::tAI_Personal::writeAI_EXTMUX_CLK_Pulse_Width(tAI_EXTMUX_CLK_Pulse_Width fieldValue, nMDBG::tStatus2* s)
{
   setAI_EXTMUX_CLK_Pulse_Width(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_Personal::tAI_EXTMUX_CLK_Pulse_Width tMSeries::tAI_Personal::readAI_EXTMUX_CLK_Pulse_Width(nMDBG::tStatus2* s)
{
   return getAI_EXTMUX_CLK_Pulse_Width(s);
}

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

inline tMSeries::tAI_Personal::tAI_CONVERT_Pulse_Width tMSeries::tAI_Personal::getAI_CONVERT_Pulse_Width(nMDBG::tStatus2*) const
{
   return (tAI_CONVERT_Pulse_Width)((_softCopy & ~0xfbff) >> 0xa);
}

inline void tMSeries::tAI_Personal::writeAI_CONVERT_Pulse_Width(tAI_CONVERT_Pulse_Width fieldValue, nMDBG::tStatus2* s)
{
   setAI_CONVERT_Pulse_Width(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_Personal::tAI_CONVERT_Pulse_Width tMSeries::tAI_Personal::readAI_CONVERT_Pulse_Width(nMDBG::tStatus2* s)
{
   return getAI_CONVERT_Pulse_Width(s);
}

inline void tMSeries::tAI_Personal::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAI_Output_Control::tAI_Output_Control()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAI_Output_Control::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAI_Output_Control::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u16 tMSeries::tAI_Output_Control::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAI_Output_Control::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u16)(0xffffffff);
}

inline void tMSeries::tAI_Output_Control::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u16 tMSeries::tAI_Output_Control::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


inline tMSeries::tAI_Output_Control& tMSeries::tAI_Output_Control::setAI_CONVERT_Output_Select(tAI_CONVERT_Output_Select fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = ((u16)(_softCopy & 0xfffc)) | (((u16)fieldValue << 0x0) & ~0xfffc);
   setRegister(newValue, s);
   return *this;
}

inline tMSeries::tAI_Output_Control::tAI_CONVERT_Output_Select tMSeries::tAI_Output_Control::getAI_CONVERT_Output_Select(nMDBG::tStatus2*) const
{
   return (tAI_CONVERT_Output_Select)((_softCopy & ~0xfffc) >> 0x0);
}

inline void tMSeries::tAI_Output_Control::writeAI_CONVERT_Output_Select(tAI_CONVERT_Output_Select fieldValue, nMDBG::tStatus2* s)
{
   setAI_CONVERT_Output_Select(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_Output_Control::tAI_CONVERT_Output_Select tMSeries::tAI_Output_Control::readAI_CONVERT_Output_Select(nMDBG::tStatus2* s)
{
   return getAI_CONVERT_Output_Select(s);
}

inline tMSeries::tAI_Output_Control& tMSeries::tAI_Output_Control::setAI_EXTMUX_CLK_Output_Select(tAI_EXTMUX_CLK_Output_Select fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = ((u16)(_softCopy & 0xff3f)) | (((u16)fieldValue << 0x6) & ~0xff3f);
   setRegister(newValue, s);
   return *this;
}

inline tMSeries::tAI_Output_Control::tAI_EXTMUX_CLK_Output_Select tMSeries::tAI_Output_Control::getAI_EXTMUX_CLK_Output_Select(nMDBG::tStatus2*) const
{
   return (tAI_EXTMUX_CLK_Output_Select)((_softCopy & ~0xff3f) >> 0x6);
}

inline void tMSeries::tAI_Output_Control::writeAI_EXTMUX_CLK_Output_Select(tAI_EXTMUX_CLK_Output_Select fieldValue, nMDBG::tStatus2* s)
{
   setAI_EXTMUX_CLK_Output_Select(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_Output_Control::tAI_EXTMUX_CLK_Output_Select tMSeries::tAI_Output_Control::readAI_EXTMUX_CLK_Output_Select(nMDBG::tStatus2* s)
{
   return getAI_EXTMUX_CLK_Output_Select(s);
}

inline tMSeries::tAI_Output_Control& tMSeries::tAI_Output_Control::setAI_SCAN_IN_PROG_Output_Select(tAI_SCAN_IN_PROG_Output_Select fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = ((u16)(_softCopy & 0xfcff)) | (((u16)fieldValue << 0x8) & ~0xfcff);
   setRegister(newValue, s);
   return *this;
}

inline tMSeries::tAI_Output_Control::tAI_SCAN_IN_PROG_Output_Select tMSeries::tAI_Output_Control::getAI_SCAN_IN_PROG_Output_Select(nMDBG::tStatus2*) const
{
   return (tAI_SCAN_IN_PROG_Output_Select)((_softCopy & ~0xfcff) >> 0x8);
}

inline void tMSeries::tAI_Output_Control::writeAI_SCAN_IN_PROG_Output_Select(tAI_SCAN_IN_PROG_Output_Select fieldValue, nMDBG::tStatus2* s)
{
   setAI_SCAN_IN_PROG_Output_Select(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_Output_Control::tAI_SCAN_IN_PROG_Output_Select tMSeries::tAI_Output_Control::readAI_SCAN_IN_PROG_Output_Select(nMDBG::tStatus2* s)
{
   return getAI_SCAN_IN_PROG_Output_Select(s);
}

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

inline tMSeries::tAI_Output_Control::tAI_START_Output_Select tMSeries::tAI_Output_Control::getAI_START_Output_Select(nMDBG::tStatus2*) const
{
   return (tAI_START_Output_Select)((_softCopy & ~0xfbff) >> 0xa);
}

inline void tMSeries::tAI_Output_Control::writeAI_START_Output_Select(tAI_START_Output_Select fieldValue, nMDBG::tStatus2* s)
{
   setAI_START_Output_Select(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_Output_Control::tAI_START_Output_Select tMSeries::tAI_Output_Control::readAI_START_Output_Select(nMDBG::tStatus2* s)
{
   return getAI_START_Output_Select(s);
}

inline void tMSeries::tAI_Output_Control::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAI_SC_Load_A::tAI_SC_Load_A()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAI_SC_Load_A::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAI_SC_Load_A::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u32 tMSeries::tAI_SC_Load_A::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAI_SC_Load_A::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u32)(0xffffffff);
}

inline void tMSeries::tAI_SC_Load_A::writeRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u32 tMSeries::tAI_SC_Load_A::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


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

inline u32 tMSeries::tAI_SC_Load_A::get(nMDBG::tStatus2*) const
{
   return (u32)((_softCopy & ~0x0) >> 0x0);
}

inline void tMSeries::tAI_SC_Load_A::write(u32 fieldValue, nMDBG::tStatus2* s)
{
   set(fieldValue, s);
   flush(s);
}
inline u32 tMSeries::tAI_SC_Load_A::read(nMDBG::tStatus2* s)
{
   return get(s);
}

inline void tMSeries::tAI_SC_Load_A::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAI_SC_Load_B::tAI_SC_Load_B()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAI_SC_Load_B::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAI_SC_Load_B::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u32 tMSeries::tAI_SC_Load_B::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAI_SC_Load_B::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u32)(0xffffffff);
}

inline void tMSeries::tAI_SC_Load_B::writeRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u32 tMSeries::tAI_SC_Load_B::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


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

inline u32 tMSeries::tAI_SC_Load_B::get(nMDBG::tStatus2*) const
{
   return (u32)((_softCopy & ~0x0) >> 0x0);
}

inline void tMSeries::tAI_SC_Load_B::write(u32 fieldValue, nMDBG::tStatus2* s)
{
   set(fieldValue, s);
   flush(s);
}
inline u32 tMSeries::tAI_SC_Load_B::read(nMDBG::tStatus2* s)
{
   return get(s);
}

inline void tMSeries::tAI_SC_Load_B::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAI_SC_Save::tAI_SC_Save()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAI_SC_Save::registerMap(void)
{
   return _MSeries;
}

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

inline u32 tMSeries::tAI_SC_Save::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

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

inline u32 tMSeries::tAI_SC_Save::get(nMDBG::tStatus2*) const
{
   return (u32)((_softCopy & ~0x0) >> 0x0);
}

inline u32 tMSeries::tAI_SC_Save::read(nMDBG::tStatus2* s)
{
   refresh(s);
   return get(s);
}

inline void tMSeries::tAI_SC_Save::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAI_SI_Load_A::tAI_SI_Load_A()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAI_SI_Load_A::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAI_SI_Load_A::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u32 tMSeries::tAI_SI_Load_A::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAI_SI_Load_A::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u32)(0x0);
}

inline void tMSeries::tAI_SI_Load_A::writeRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u32 tMSeries::tAI_SI_Load_A::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


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

inline u32 tMSeries::tAI_SI_Load_A::get(nMDBG::tStatus2*) const
{
   return (u32)((_softCopy & ~0x0) >> 0x0);
}

inline void tMSeries::tAI_SI_Load_A::write(u32 fieldValue, nMDBG::tStatus2* s)
{
   set(fieldValue, s);
   flush(s);
}
inline u32 tMSeries::tAI_SI_Load_A::read(nMDBG::tStatus2* s)
{
   return get(s);
}

inline void tMSeries::tAI_SI_Load_A::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAI_SI_Load_B::tAI_SI_Load_B()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAI_SI_Load_B::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAI_SI_Load_B::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u32 tMSeries::tAI_SI_Load_B::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAI_SI_Load_B::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u32)(0xffffffff);
}

inline void tMSeries::tAI_SI_Load_B::writeRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u32 tMSeries::tAI_SI_Load_B::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


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

inline u32 tMSeries::tAI_SI_Load_B::get(nMDBG::tStatus2*) const
{
   return (u32)((_softCopy & ~0x0) >> 0x0);
}

inline void tMSeries::tAI_SI_Load_B::write(u32 fieldValue, nMDBG::tStatus2* s)
{
   set(fieldValue, s);
   flush(s);
}
inline u32 tMSeries::tAI_SI_Load_B::read(nMDBG::tStatus2* s)
{
   return get(s);
}

inline void tMSeries::tAI_SI_Load_B::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAI_SI_Save::tAI_SI_Save()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAI_SI_Save::registerMap(void)
{
   return _MSeries;
}

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

inline u32 tMSeries::tAI_SI_Save::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

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

inline u32 tMSeries::tAI_SI_Save::get(nMDBG::tStatus2*) const
{
   return (u32)((_softCopy & ~0x0) >> 0x0);
}

inline u32 tMSeries::tAI_SI_Save::read(nMDBG::tStatus2* s)
{
   refresh(s);
   return get(s);
}

inline void tMSeries::tAI_SI_Save::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAI_SI2_Load_A::tAI_SI2_Load_A()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAI_SI2_Load_A::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAI_SI2_Load_A::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u32 tMSeries::tAI_SI2_Load_A::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAI_SI2_Load_A::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u32)(0xffffffff);
}

inline void tMSeries::tAI_SI2_Load_A::writeRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u32 tMSeries::tAI_SI2_Load_A::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


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

inline u32 tMSeries::tAI_SI2_Load_A::get(nMDBG::tStatus2*) const
{
   return (u32)((_softCopy & ~0x0) >> 0x0);
}

inline void tMSeries::tAI_SI2_Load_A::write(u32 fieldValue, nMDBG::tStatus2* s)
{
   set(fieldValue, s);
   flush(s);
}
inline u32 tMSeries::tAI_SI2_Load_A::read(nMDBG::tStatus2* s)
{
   return get(s);
}

inline void tMSeries::tAI_SI2_Load_A::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAI_SI2_Load_B::tAI_SI2_Load_B()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAI_SI2_Load_B::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAI_SI2_Load_B::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u32 tMSeries::tAI_SI2_Load_B::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAI_SI2_Load_B::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u32)(0xffffffff);
}

inline void tMSeries::tAI_SI2_Load_B::writeRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u32 tMSeries::tAI_SI2_Load_B::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


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

inline u32 tMSeries::tAI_SI2_Load_B::get(nMDBG::tStatus2*) const
{
   return (u32)((_softCopy & ~0x0) >> 0x0);
}

inline void tMSeries::tAI_SI2_Load_B::write(u32 fieldValue, nMDBG::tStatus2* s)
{
   set(fieldValue, s);
   flush(s);
}
inline u32 tMSeries::tAI_SI2_Load_B::read(nMDBG::tStatus2* s)
{
   return get(s);
}

inline void tMSeries::tAI_SI2_Load_B::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAI_START_STOP_Select::tAI_START_STOP_Select()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAI_START_STOP_Select::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAI_START_STOP_Select::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u16 tMSeries::tAI_START_STOP_Select::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAI_START_STOP_Select::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u16)(0xffffffff);
}

inline void tMSeries::tAI_START_STOP_Select::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u16 tMSeries::tAI_START_STOP_Select::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


inline tMSeries::tAI_START_STOP_Select& tMSeries::tAI_START_STOP_Select::setAI_START_Select(tAI_START_Select fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = ((u16)(_softCopy & 0xffe0)) | (((u16)fieldValue << 0x0) & ~0xffe0);
   setRegister(newValue, s);
   return *this;
}

inline tMSeries::tAI_START_STOP_Select::tAI_START_Select tMSeries::tAI_START_STOP_Select::getAI_START_Select(nMDBG::tStatus2*) const
{
   return (tAI_START_Select)((_softCopy & ~0xffe0) >> 0x0);
}

inline void tMSeries::tAI_START_STOP_Select::writeAI_START_Select(tAI_START_Select fieldValue, nMDBG::tStatus2* s)
{
   setAI_START_Select(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_START_STOP_Select::tAI_START_Select tMSeries::tAI_START_STOP_Select::readAI_START_Select(nMDBG::tStatus2* s)
{
   return getAI_START_Select(s);
}

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

inline tBoolean tMSeries::tAI_START_STOP_Select::getAI_START_Edge(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xffdf) >> 0x5);
}

inline void tMSeries::tAI_START_STOP_Select::writeAI_START_Edge(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAI_START_Edge(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAI_START_STOP_Select::readAI_START_Edge(nMDBG::tStatus2* s)
{
   return getAI_START_Edge(s);
}

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

inline tBoolean tMSeries::tAI_START_STOP_Select::getAI_START_Sync(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xffbf) >> 0x6);
}

inline void tMSeries::tAI_START_STOP_Select::writeAI_START_Sync(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAI_START_Sync(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAI_START_STOP_Select::readAI_START_Sync(nMDBG::tStatus2* s)
{
   return getAI_START_Sync(s);
}

inline tMSeries::tAI_START_STOP_Select& tMSeries::tAI_START_STOP_Select::setAI_STOP_Select(tAI_STOP_Select fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = ((u16)(_softCopy & 0xf07f)) | (((u16)fieldValue << 0x7) & ~0xf07f);
   setRegister(newValue, s);
   return *this;
}

inline tMSeries::tAI_START_STOP_Select::tAI_STOP_Select tMSeries::tAI_START_STOP_Select::getAI_STOP_Select(nMDBG::tStatus2*) const
{
   return (tAI_STOP_Select)((_softCopy & ~0xf07f) >> 0x7);
}

inline void tMSeries::tAI_START_STOP_Select::writeAI_STOP_Select(tAI_STOP_Select fieldValue, nMDBG::tStatus2* s)
{
   setAI_STOP_Select(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_START_STOP_Select::tAI_STOP_Select tMSeries::tAI_START_STOP_Select::readAI_STOP_Select(nMDBG::tStatus2* s)
{
   return getAI_STOP_Select(s);
}

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

inline tBoolean tMSeries::tAI_START_STOP_Select::getAI_STOP_Edge(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xefff) >> 0xc);
}

inline void tMSeries::tAI_START_STOP_Select::writeAI_STOP_Edge(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAI_STOP_Edge(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAI_START_STOP_Select::readAI_STOP_Edge(nMDBG::tStatus2* s)
{
   return getAI_STOP_Edge(s);
}

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

inline tBoolean tMSeries::tAI_START_STOP_Select::getAI_STOP_Sync(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xdfff) >> 0xd);
}

inline void tMSeries::tAI_START_STOP_Select::writeAI_STOP_Sync(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAI_STOP_Sync(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAI_START_STOP_Select::readAI_STOP_Sync(nMDBG::tStatus2* s)
{
   return getAI_STOP_Sync(s);
}

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

inline tMSeries::tAI_START_STOP_Select::tAI_STOP_Polarity tMSeries::tAI_START_STOP_Select::getAI_STOP_Polarity(nMDBG::tStatus2*) const
{
   return (tAI_STOP_Polarity)((_softCopy & ~0xbfff) >> 0xe);
}

inline void tMSeries::tAI_START_STOP_Select::writeAI_STOP_Polarity(tAI_STOP_Polarity fieldValue, nMDBG::tStatus2* s)
{
   setAI_STOP_Polarity(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_START_STOP_Select::tAI_STOP_Polarity tMSeries::tAI_START_STOP_Select::readAI_STOP_Polarity(nMDBG::tStatus2* s)
{
   return getAI_STOP_Polarity(s);
}

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

inline tMSeries::tAI_START_STOP_Select::tAI_START_Polarity tMSeries::tAI_START_STOP_Select::getAI_START_Polarity(nMDBG::tStatus2*) const
{
   return (tAI_START_Polarity)((_softCopy & ~0x7fff) >> 0xf);
}

inline void tMSeries::tAI_START_STOP_Select::writeAI_START_Polarity(tAI_START_Polarity fieldValue, nMDBG::tStatus2* s)
{
   setAI_START_Polarity(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_START_STOP_Select::tAI_START_Polarity tMSeries::tAI_START_STOP_Select::readAI_START_Polarity(nMDBG::tStatus2* s)
{
   return getAI_START_Polarity(s);
}

inline void tMSeries::tAI_START_STOP_Select::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAI_Status_1::tAI_Status_1()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAI_Status_1::registerMap(void)
{
   return _MSeries;
}

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

inline u16 tMSeries::tAI_Status_1::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

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

inline tBoolean tMSeries::tAI_Status_1::getPass_Thru_0_Interrupt_St(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xfffe) >> 0x0);
}

inline tBoolean tMSeries::tAI_Status_1::readPass_Thru_0_Interrupt_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getPass_Thru_0_Interrupt_St(s);
}

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

inline tBoolean tMSeries::tAI_Status_1::getAI_FIFO_Request_St(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xfffd) >> 0x1);
}

inline tBoolean tMSeries::tAI_Status_1::readAI_FIFO_Request_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAI_FIFO_Request_St(s);
}

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

inline tBoolean tMSeries::tAI_Status_1::getG0_Gate_Interrupt_St(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xfffb) >> 0x2);
}

inline tBoolean tMSeries::tAI_Status_1::readG0_Gate_Interrupt_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getG0_Gate_Interrupt_St(s);
}

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

inline tBoolean tMSeries::tAI_Status_1::getG0_TC_St(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xfff7) >> 0x3);
}

inline tBoolean tMSeries::tAI_Status_1::readG0_TC_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getG0_TC_St(s);
}

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

inline tBoolean tMSeries::tAI_Status_1::getAI_STOP_St(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xffef) >> 0x4);
}

inline tBoolean tMSeries::tAI_Status_1::readAI_STOP_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAI_STOP_St(s);
}

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

inline tBoolean tMSeries::tAI_Status_1::getAI_START_St(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xffdf) >> 0x5);
}

inline tBoolean tMSeries::tAI_Status_1::readAI_START_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAI_START_St(s);
}

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

inline tBoolean tMSeries::tAI_Status_1::getAI_SC_TC_St(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xffbf) >> 0x6);
}

inline tBoolean tMSeries::tAI_Status_1::readAI_SC_TC_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAI_SC_TC_St(s);
}

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

inline tBoolean tMSeries::tAI_Status_1::getAI_START1_St(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xff7f) >> 0x7);
}

inline tBoolean tMSeries::tAI_Status_1::readAI_START1_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAI_START1_St(s);
}

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

inline tBoolean tMSeries::tAI_Status_1::getAI_START2_St(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xfeff) >> 0x8);
}

inline tBoolean tMSeries::tAI_Status_1::readAI_START2_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAI_START2_St(s);
}

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

inline tBoolean tMSeries::tAI_Status_1::getAI_SC_TC_Error_St(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xfdff) >> 0x9);
}

inline tBoolean tMSeries::tAI_Status_1::readAI_SC_TC_Error_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAI_SC_TC_Error_St(s);
}

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

inline tBoolean tMSeries::tAI_Status_1::getAI_Overflow_St(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xfbff) >> 0xa);
}

inline tBoolean tMSeries::tAI_Status_1::readAI_Overflow_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAI_Overflow_St(s);
}

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

inline tBoolean tMSeries::tAI_Status_1::getAI_Overrun_St(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xf7ff) >> 0xb);
}

inline tBoolean tMSeries::tAI_Status_1::readAI_Overrun_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAI_Overrun_St(s);
}

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

inline tBoolean tMSeries::tAI_Status_1::getAI_FIFO_Empty_St(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xefff) >> 0xc);
}

inline tBoolean tMSeries::tAI_Status_1::readAI_FIFO_Empty_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAI_FIFO_Empty_St(s);
}

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

inline tBoolean tMSeries::tAI_Status_1::getAI_FIFO_Half_Full_St(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xdfff) >> 0xd);
}

inline tBoolean tMSeries::tAI_Status_1::readAI_FIFO_Half_Full_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAI_FIFO_Half_Full_St(s);
}

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

inline tBoolean tMSeries::tAI_Status_1::getAI_FIFO_Full_St(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xbfff) >> 0xe);
}

inline tBoolean tMSeries::tAI_Status_1::readAI_FIFO_Full_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAI_FIFO_Full_St(s);
}

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

inline tBoolean tMSeries::tAI_Status_1::getInterrupt_Group_A_Status(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0x7fff) >> 0xf);
}

inline tBoolean tMSeries::tAI_Status_1::readInterrupt_Group_A_Status(nMDBG::tStatus2* s)
{
   refresh(s);
   return getInterrupt_Group_A_Status(s);
}

inline void tMSeries::tAI_Status_1::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAnalog_Trigger_Etc::tAnalog_Trigger_Etc()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAnalog_Trigger_Etc::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAnalog_Trigger_Etc::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u16 tMSeries::tAnalog_Trigger_Etc::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAnalog_Trigger_Etc::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u16)(0xffffffdf);
}

inline void tMSeries::tAnalog_Trigger_Etc::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u16 tMSeries::tAnalog_Trigger_Etc::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


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

inline tMSeries::tAnalog_Trigger_Etc::tAnalog_Trigger_Mode tMSeries::tAnalog_Trigger_Etc::getAnalog_Trigger_Mode(nMDBG::tStatus2*) const
{
   return (tAnalog_Trigger_Mode)((_softCopy & ~0xfff8) >> 0x0);
}

inline void tMSeries::tAnalog_Trigger_Etc::writeAnalog_Trigger_Mode(tAnalog_Trigger_Mode fieldValue, nMDBG::tStatus2* s)
{
   setAnalog_Trigger_Mode(fieldValue, s);
   flush(s);
}
inline tMSeries::tAnalog_Trigger_Etc::tAnalog_Trigger_Mode tMSeries::tAnalog_Trigger_Etc::readAnalog_Trigger_Mode(nMDBG::tStatus2* s)
{
   return getAnalog_Trigger_Mode(s);
}

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

inline tMSeries::tAnalog_Trigger_Etc::tAnalog_Trigger_Enable tMSeries::tAnalog_Trigger_Etc::getAnalog_Trigger_Enable(nMDBG::tStatus2*) const
{
   return (tAnalog_Trigger_Enable)((_softCopy & ~0xfff7) >> 0x3);
}

inline void tMSeries::tAnalog_Trigger_Etc::writeAnalog_Trigger_Enable(tAnalog_Trigger_Enable fieldValue, nMDBG::tStatus2* s)
{
   setAnalog_Trigger_Enable(fieldValue, s);
   flush(s);
}
inline tMSeries::tAnalog_Trigger_Etc::tAnalog_Trigger_Enable tMSeries::tAnalog_Trigger_Etc::readAnalog_Trigger_Enable(nMDBG::tStatus2* s)
{
   return getAnalog_Trigger_Enable(s);
}

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

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

inline void tMSeries::tAnalog_Trigger_Etc::writeAnalog_Trigger_Reset(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAnalog_Trigger_Reset(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAnalog_Trigger_Etc::readAnalog_Trigger_Reset(nMDBG::tStatus2* s)
{
   return getAnalog_Trigger_Reset(s);
}

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

inline u16 tMSeries::tAnalog_Trigger_Etc::getMisc_Counter_TCs_Output_Enable(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xffbf) >> 0x6);
}

inline void tMSeries::tAnalog_Trigger_Etc::writeMisc_Counter_TCs_Output_Enable(u16 fieldValue, nMDBG::tStatus2* s)
{
   setMisc_Counter_TCs_Output_Enable(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAnalog_Trigger_Etc::readMisc_Counter_TCs_Output_Enable(nMDBG::tStatus2* s)
{
   return getMisc_Counter_TCs_Output_Enable(s);
}

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

inline tMSeries::tAnalog_Trigger_Etc::tGPFO_1_Output_Select tMSeries::tAnalog_Trigger_Etc::getGPFO_1_Output_Select(nMDBG::tStatus2*) const
{
   return (tGPFO_1_Output_Select)((_softCopy & ~0xff7f) >> 0x7);
}

inline void tMSeries::tAnalog_Trigger_Etc::writeGPFO_1_Output_Select(tGPFO_1_Output_Select fieldValue, nMDBG::tStatus2* s)
{
   setGPFO_1_Output_Select(fieldValue, s);
   flush(s);
}
inline tMSeries::tAnalog_Trigger_Etc::tGPFO_1_Output_Select tMSeries::tAnalog_Trigger_Etc::readGPFO_1_Output_Select(nMDBG::tStatus2* s)
{
   return getGPFO_1_Output_Select(s);
}

inline tMSeries::tAnalog_Trigger_Etc& tMSeries::tAnalog_Trigger_Etc::setGPFO_0_Output_Select(tGPFO_0_Output_Select fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = ((u16)(_softCopy & 0xc7ff)) | (((u16)fieldValue << 0xb) & ~0xc7ff);
   setRegister(newValue, s);
   return *this;
}

inline tMSeries::tAnalog_Trigger_Etc::tGPFO_0_Output_Select tMSeries::tAnalog_Trigger_Etc::getGPFO_0_Output_Select(nMDBG::tStatus2*) const
{
   return (tGPFO_0_Output_Select)((_softCopy & ~0xc7ff) >> 0xb);
}

inline void tMSeries::tAnalog_Trigger_Etc::writeGPFO_0_Output_Select(tGPFO_0_Output_Select fieldValue, nMDBG::tStatus2* s)
{
   setGPFO_0_Output_Select(fieldValue, s);
   flush(s);
}
inline tMSeries::tAnalog_Trigger_Etc::tGPFO_0_Output_Select tMSeries::tAnalog_Trigger_Etc::readGPFO_0_Output_Select(nMDBG::tStatus2* s)
{
   return getGPFO_0_Output_Select(s);
}

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

inline tMSeries::tAnalog_Trigger_Etc::tGPFO_0_Output_Enable tMSeries::tAnalog_Trigger_Etc::getGPFO_0_Output_Enable(nMDBG::tStatus2*) const
{
   return (tGPFO_0_Output_Enable)((_softCopy & ~0xbfff) >> 0xe);
}

inline void tMSeries::tAnalog_Trigger_Etc::writeGPFO_0_Output_Enable(tGPFO_0_Output_Enable fieldValue, nMDBG::tStatus2* s)
{
   setGPFO_0_Output_Enable(fieldValue, s);
   flush(s);
}
inline tMSeries::tAnalog_Trigger_Etc::tGPFO_0_Output_Enable tMSeries::tAnalog_Trigger_Etc::readGPFO_0_Output_Enable(nMDBG::tStatus2* s)
{
   return getGPFO_0_Output_Enable(s);
}

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

inline tMSeries::tAnalog_Trigger_Etc::tGPFO_1_Output_Enable tMSeries::tAnalog_Trigger_Etc::getGPFO_1_Output_Enable(nMDBG::tStatus2*) const
{
   return (tGPFO_1_Output_Enable)((_softCopy & ~0x7fff) >> 0xf);
}

inline void tMSeries::tAnalog_Trigger_Etc::writeGPFO_1_Output_Enable(tGPFO_1_Output_Enable fieldValue, nMDBG::tStatus2* s)
{
   setGPFO_1_Output_Enable(fieldValue, s);
   flush(s);
}
inline tMSeries::tAnalog_Trigger_Etc::tGPFO_1_Output_Enable tMSeries::tAnalog_Trigger_Etc::readGPFO_1_Output_Enable(nMDBG::tStatus2* s)
{
   return getGPFO_1_Output_Enable(s);
}

inline void tMSeries::tAnalog_Trigger_Etc::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAI_Trigger_Select::tAI_Trigger_Select()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAI_Trigger_Select::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAI_Trigger_Select::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u16 tMSeries::tAI_Trigger_Select::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAI_Trigger_Select::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u16)(0xffffffff);
}

inline void tMSeries::tAI_Trigger_Select::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u16 tMSeries::tAI_Trigger_Select::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


inline tMSeries::tAI_Trigger_Select& tMSeries::tAI_Trigger_Select::setAI_START1_Select(tAI_START1_Select fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = ((u16)(_softCopy & 0xffe0)) | (((u16)fieldValue << 0x0) & ~0xffe0);
   setRegister(newValue, s);
   return *this;
}

inline tMSeries::tAI_Trigger_Select::tAI_START1_Select tMSeries::tAI_Trigger_Select::getAI_START1_Select(nMDBG::tStatus2*) const
{
   return (tAI_START1_Select)((_softCopy & ~0xffe0) >> 0x0);
}

inline void tMSeries::tAI_Trigger_Select::writeAI_START1_Select(tAI_START1_Select fieldValue, nMDBG::tStatus2* s)
{
   setAI_START1_Select(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_Trigger_Select::tAI_START1_Select tMSeries::tAI_Trigger_Select::readAI_START1_Select(nMDBG::tStatus2* s)
{
   return getAI_START1_Select(s);
}

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

inline tBoolean tMSeries::tAI_Trigger_Select::getAI_START1_Edge(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xffdf) >> 0x5);
}

inline void tMSeries::tAI_Trigger_Select::writeAI_START1_Edge(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAI_START1_Edge(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAI_Trigger_Select::readAI_START1_Edge(nMDBG::tStatus2* s)
{
   return getAI_START1_Edge(s);
}

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

inline tBoolean tMSeries::tAI_Trigger_Select::getAI_START1_Sync(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xffbf) >> 0x6);
}

inline void tMSeries::tAI_Trigger_Select::writeAI_START1_Sync(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAI_START1_Sync(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAI_Trigger_Select::readAI_START1_Sync(nMDBG::tStatus2* s)
{
   return getAI_START1_Sync(s);
}

inline tMSeries::tAI_Trigger_Select& tMSeries::tAI_Trigger_Select::setAI_START2_Select(tAI_START2_Select fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = ((u16)(_softCopy & 0xf07f)) | (((u16)fieldValue << 0x7) & ~0xf07f);
   setRegister(newValue, s);
   return *this;
}

inline tMSeries::tAI_Trigger_Select::tAI_START2_Select tMSeries::tAI_Trigger_Select::getAI_START2_Select(nMDBG::tStatus2*) const
{
   return (tAI_START2_Select)((_softCopy & ~0xf07f) >> 0x7);
}

inline void tMSeries::tAI_Trigger_Select::writeAI_START2_Select(tAI_START2_Select fieldValue, nMDBG::tStatus2* s)
{
   setAI_START2_Select(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_Trigger_Select::tAI_START2_Select tMSeries::tAI_Trigger_Select::readAI_START2_Select(nMDBG::tStatus2* s)
{
   return getAI_START2_Select(s);
}

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

inline tBoolean tMSeries::tAI_Trigger_Select::getAI_START2_Edge(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xefff) >> 0xc);
}

inline void tMSeries::tAI_Trigger_Select::writeAI_START2_Edge(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAI_START2_Edge(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAI_Trigger_Select::readAI_START2_Edge(nMDBG::tStatus2* s)
{
   return getAI_START2_Edge(s);
}

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

inline tBoolean tMSeries::tAI_Trigger_Select::getAI_START2_Sync(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xdfff) >> 0xd);
}

inline void tMSeries::tAI_Trigger_Select::writeAI_START2_Sync(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAI_START2_Sync(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAI_Trigger_Select::readAI_START2_Sync(nMDBG::tStatus2* s)
{
   return getAI_START2_Sync(s);
}

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

inline tMSeries::tAI_Trigger_Select::tAI_START2_Polarity tMSeries::tAI_Trigger_Select::getAI_START2_Polarity(nMDBG::tStatus2*) const
{
   return (tAI_START2_Polarity)((_softCopy & ~0xbfff) >> 0xe);
}

inline void tMSeries::tAI_Trigger_Select::writeAI_START2_Polarity(tAI_START2_Polarity fieldValue, nMDBG::tStatus2* s)
{
   setAI_START2_Polarity(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_Trigger_Select::tAI_START2_Polarity tMSeries::tAI_Trigger_Select::readAI_START2_Polarity(nMDBG::tStatus2* s)
{
   return getAI_START2_Polarity(s);
}

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

inline tMSeries::tAI_Trigger_Select::tAI_START1_Polarity tMSeries::tAI_Trigger_Select::getAI_START1_Polarity(nMDBG::tStatus2*) const
{
   return (tAI_START1_Polarity)((_softCopy & ~0x7fff) >> 0xf);
}

inline void tMSeries::tAI_Trigger_Select::writeAI_START1_Polarity(tAI_START1_Polarity fieldValue, nMDBG::tStatus2* s)
{
   setAI_START1_Polarity(fieldValue, s);
   flush(s);
}
inline tMSeries::tAI_Trigger_Select::tAI_START1_Polarity tMSeries::tAI_Trigger_Select::readAI_START1_Polarity(nMDBG::tStatus2* s)
{
   return getAI_START1_Polarity(s);
}

inline void tMSeries::tAI_Trigger_Select::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAO_BC_Load_A::tAO_BC_Load_A()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAO_BC_Load_A::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAO_BC_Load_A::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u32 tMSeries::tAO_BC_Load_A::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAO_BC_Load_A::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u32)(0xffffffff);
}

inline void tMSeries::tAO_BC_Load_A::writeRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u32 tMSeries::tAO_BC_Load_A::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


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

inline u32 tMSeries::tAO_BC_Load_A::get(nMDBG::tStatus2*) const
{
   return (u32)((_softCopy & ~0x0) >> 0x0);
}

inline void tMSeries::tAO_BC_Load_A::write(u32 fieldValue, nMDBG::tStatus2* s)
{
   set(fieldValue, s);
   flush(s);
}
inline u32 tMSeries::tAO_BC_Load_A::read(nMDBG::tStatus2* s)
{
   return get(s);
}

inline void tMSeries::tAO_BC_Load_A::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAO_BC_Load_B::tAO_BC_Load_B()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAO_BC_Load_B::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAO_BC_Load_B::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u32 tMSeries::tAO_BC_Load_B::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAO_BC_Load_B::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u32)(0xffffffff);
}

inline void tMSeries::tAO_BC_Load_B::writeRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u32 tMSeries::tAO_BC_Load_B::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


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

inline u32 tMSeries::tAO_BC_Load_B::get(nMDBG::tStatus2*) const
{
   return (u32)((_softCopy & ~0x0) >> 0x0);
}

inline void tMSeries::tAO_BC_Load_B::write(u32 fieldValue, nMDBG::tStatus2* s)
{
   set(fieldValue, s);
   flush(s);
}
inline u32 tMSeries::tAO_BC_Load_B::read(nMDBG::tStatus2* s)
{
   return get(s);
}

inline void tMSeries::tAO_BC_Load_B::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAO_BC_Save::tAO_BC_Save()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAO_BC_Save::registerMap(void)
{
   return _MSeries;
}

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

inline u32 tMSeries::tAO_BC_Save::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

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

inline u32 tMSeries::tAO_BC_Save::get(nMDBG::tStatus2*) const
{
   return (u32)((_softCopy & ~0x0) >> 0x0);
}

inline u32 tMSeries::tAO_BC_Save::read(nMDBG::tStatus2* s)
{
   refresh(s);
   return get(s);
}

inline void tMSeries::tAO_BC_Save::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAO_Command_2::tAO_Command_2()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAO_Command_2::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAO_Command_2::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u16 tMSeries::tAO_Command_2::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAO_Command_2::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u16)(0xffff3c0e);
}

inline void tMSeries::tAO_Command_2::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u16 tMSeries::tAO_Command_2::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


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

inline u16 tMSeries::tAO_Command_2::getAO_START1_Pulse(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfffe) >> 0x0);
}

inline void tMSeries::tAO_Command_2::writeAO_START1_Pulse(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_START1_Pulse(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Command_2::readAO_START1_Pulse(nMDBG::tStatus2* s)
{
   return getAO_START1_Pulse(s);
}

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

inline u16 tMSeries::tAO_Command_2::getAO_Mute_A(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfffb) >> 0x2);
}

inline void tMSeries::tAO_Command_2::writeAO_Mute_A(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_Mute_A(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Command_2::readAO_Mute_A(nMDBG::tStatus2* s)
{
   return getAO_Mute_A(s);
}

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

inline u16 tMSeries::tAO_Command_2::getAO_Mute_B(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfff7) >> 0x3);
}

inline void tMSeries::tAO_Command_2::writeAO_Mute_B(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_Mute_B(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Command_2::readAO_Mute_B(nMDBG::tStatus2* s)
{
   return getAO_Mute_B(s);
}

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

inline u16 tMSeries::tAO_Command_2::getAO_BC_Switch_Load_On_TC(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xffef) >> 0x4);
}

inline void tMSeries::tAO_Command_2::writeAO_BC_Switch_Load_On_TC(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_BC_Switch_Load_On_TC(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Command_2::readAO_BC_Switch_Load_On_TC(nMDBG::tStatus2* s)
{
   return getAO_BC_Switch_Load_On_TC(s);
}

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

inline u16 tMSeries::tAO_Command_2::getAO_UC_Switch_Load_On_TC(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xffdf) >> 0x5);
}

inline void tMSeries::tAO_Command_2::writeAO_UC_Switch_Load_On_TC(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_UC_Switch_Load_On_TC(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Command_2::readAO_UC_Switch_Load_On_TC(nMDBG::tStatus2* s)
{
   return getAO_UC_Switch_Load_On_TC(s);
}

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

inline u16 tMSeries::tAO_Command_2::getAO_UC_Switch_Load_On_BC_TC(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xffbf) >> 0x6);
}

inline void tMSeries::tAO_Command_2::writeAO_UC_Switch_Load_On_BC_TC(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_UC_Switch_Load_On_BC_TC(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Command_2::readAO_UC_Switch_Load_On_BC_TC(nMDBG::tStatus2* s)
{
   return getAO_UC_Switch_Load_On_BC_TC(s);
}

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

inline u16 tMSeries::tAO_Command_2::getAO_UI_Switch_Load_On_TC(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xff7f) >> 0x7);
}

inline void tMSeries::tAO_Command_2::writeAO_UI_Switch_Load_On_TC(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_UI_Switch_Load_On_TC(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Command_2::readAO_UI_Switch_Load_On_TC(nMDBG::tStatus2* s)
{
   return getAO_UI_Switch_Load_On_TC(s);
}

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

inline u16 tMSeries::tAO_Command_2::getAO_UI_Switch_Load_On_Stop(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfeff) >> 0x8);
}

inline void tMSeries::tAO_Command_2::writeAO_UI_Switch_Load_On_Stop(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_UI_Switch_Load_On_Stop(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Command_2::readAO_UI_Switch_Load_On_Stop(nMDBG::tStatus2* s)
{
   return getAO_UI_Switch_Load_On_Stop(s);
}

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

inline u16 tMSeries::tAO_Command_2::getAO_UI_Switch_Load_On_BC_TC(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfdff) >> 0x9);
}

inline void tMSeries::tAO_Command_2::writeAO_UI_Switch_Load_On_BC_TC(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_UI_Switch_Load_On_BC_TC(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Command_2::readAO_UI_Switch_Load_On_BC_TC(nMDBG::tStatus2* s)
{
   return getAO_UI_Switch_Load_On_BC_TC(s);
}

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

inline u16 tMSeries::tAO_Command_2::getAO_BC_Save_Trace(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfbff) >> 0xa);
}

inline void tMSeries::tAO_Command_2::writeAO_BC_Save_Trace(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_BC_Save_Trace(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Command_2::readAO_BC_Save_Trace(nMDBG::tStatus2* s)
{
   return getAO_BC_Save_Trace(s);
}

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

inline tBoolean tMSeries::tAO_Command_2::getAO_BC_Gate_Enable(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xf7ff) >> 0xb);
}

inline void tMSeries::tAO_Command_2::writeAO_BC_Gate_Enable(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAO_BC_Gate_Enable(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAO_Command_2::readAO_BC_Gate_Enable(nMDBG::tStatus2* s)
{
   return getAO_BC_Gate_Enable(s);
}

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

inline u16 tMSeries::tAO_Command_2::getAO_UC_Save_Trace(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xefff) >> 0xc);
}

inline void tMSeries::tAO_Command_2::writeAO_UC_Save_Trace(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_UC_Save_Trace(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Command_2::readAO_UC_Save_Trace(nMDBG::tStatus2* s)
{
   return getAO_UC_Save_Trace(s);
}

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

inline u16 tMSeries::tAO_Command_2::getAO_Start_Stop_Gate_Enable(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xdfff) >> 0xd);
}

inline void tMSeries::tAO_Command_2::writeAO_Start_Stop_Gate_Enable(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_Start_Stop_Gate_Enable(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Command_2::readAO_Start_Stop_Gate_Enable(nMDBG::tStatus2* s)
{
   return getAO_Start_Stop_Gate_Enable(s);
}

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

inline u16 tMSeries::tAO_Command_2::getAO_End_On_UC_TC(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xbfff) >> 0xe);
}

inline void tMSeries::tAO_Command_2::writeAO_End_On_UC_TC(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_End_On_UC_TC(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Command_2::readAO_End_On_UC_TC(nMDBG::tStatus2* s)
{
   return getAO_End_On_UC_TC(s);
}

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

inline u16 tMSeries::tAO_Command_2::getAO_End_On_BC_TC(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0x7fff) >> 0xf);
}

inline void tMSeries::tAO_Command_2::writeAO_End_On_BC_TC(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_End_On_BC_TC(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Command_2::readAO_End_On_BC_TC(nMDBG::tStatus2* s)
{
   return getAO_End_On_BC_TC(s);
}

inline void tMSeries::tAO_Command_2::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAO_Command_1::tAO_Command_1()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAO_Command_1::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAO_Command_1::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u16 tMSeries::tAO_Command_1::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAO_Command_1::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u16)(0xffff181e);
}

inline void tMSeries::tAO_Command_1::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u16 tMSeries::tAO_Command_1::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


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

inline u16 tMSeries::tAO_Command_1::getAO_UPDATE_Pulse(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfffe) >> 0x0);
}

inline void tMSeries::tAO_Command_1::writeAO_UPDATE_Pulse(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_UPDATE_Pulse(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Command_1::readAO_UPDATE_Pulse(nMDBG::tStatus2* s)
{
   return getAO_UPDATE_Pulse(s);
}

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

inline tMSeries::tAO_Command_1::tAO_DAC0_Update_Mode tMSeries::tAO_Command_1::getAO_DAC0_Update_Mode(nMDBG::tStatus2*) const
{
   return (tAO_DAC0_Update_Mode)((_softCopy & ~0xfffb) >> 0x2);
}

inline void tMSeries::tAO_Command_1::writeAO_DAC0_Update_Mode(tAO_DAC0_Update_Mode fieldValue, nMDBG::tStatus2* s)
{
   setAO_DAC0_Update_Mode(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_Command_1::tAO_DAC0_Update_Mode tMSeries::tAO_Command_1::readAO_DAC0_Update_Mode(nMDBG::tStatus2* s)
{
   return getAO_DAC0_Update_Mode(s);
}

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

inline tMSeries::tAO_Command_1::tAO_DAC1_Update_Mode tMSeries::tAO_Command_1::getAO_DAC1_Update_Mode(nMDBG::tStatus2*) const
{
   return (tAO_DAC1_Update_Mode)((_softCopy & ~0xffef) >> 0x4);
}

inline void tMSeries::tAO_Command_1::writeAO_DAC1_Update_Mode(tAO_DAC1_Update_Mode fieldValue, nMDBG::tStatus2* s)
{
   setAO_DAC1_Update_Mode(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_Command_1::tAO_DAC1_Update_Mode tMSeries::tAO_Command_1::readAO_DAC1_Update_Mode(nMDBG::tStatus2* s)
{
   return getAO_DAC1_Update_Mode(s);
}

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

inline u16 tMSeries::tAO_Command_1::getAO_BC_Load(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xffdf) >> 0x5);
}

inline void tMSeries::tAO_Command_1::writeAO_BC_Load(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_BC_Load(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Command_1::readAO_BC_Load(nMDBG::tStatus2* s)
{
   return getAO_BC_Load(s);
}

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

inline u16 tMSeries::tAO_Command_1::getAO_BC_Arm(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xffbf) >> 0x6);
}

inline void tMSeries::tAO_Command_1::writeAO_BC_Arm(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_BC_Arm(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Command_1::readAO_BC_Arm(nMDBG::tStatus2* s)
{
   return getAO_BC_Arm(s);
}

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

inline u16 tMSeries::tAO_Command_1::getAO_UC_Load(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xff7f) >> 0x7);
}

inline void tMSeries::tAO_Command_1::writeAO_UC_Load(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_UC_Load(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Command_1::readAO_UC_Load(nMDBG::tStatus2* s)
{
   return getAO_UC_Load(s);
}

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

inline u16 tMSeries::tAO_Command_1::getAO_UC_Arm(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfeff) >> 0x8);
}

inline void tMSeries::tAO_Command_1::writeAO_UC_Arm(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_UC_Arm(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Command_1::readAO_UC_Arm(nMDBG::tStatus2* s)
{
   return getAO_UC_Arm(s);
}

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

inline u16 tMSeries::tAO_Command_1::getAO_UI_Load(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfdff) >> 0x9);
}

inline void tMSeries::tAO_Command_1::writeAO_UI_Load(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_UI_Load(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Command_1::readAO_UI_Load(nMDBG::tStatus2* s)
{
   return getAO_UI_Load(s);
}

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

inline u16 tMSeries::tAO_Command_1::getAO_UI_Arm(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfbff) >> 0xa);
}

inline void tMSeries::tAO_Command_1::writeAO_UI_Arm(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_UI_Arm(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Command_1::readAO_UI_Arm(nMDBG::tStatus2* s)
{
   return getAO_UI_Arm(s);
}

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

inline u16 tMSeries::tAO_Command_1::getAO_Disarm(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xdfff) >> 0xd);
}

inline void tMSeries::tAO_Command_1::writeAO_Disarm(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_Disarm(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Command_1::readAO_Disarm(nMDBG::tStatus2* s)
{
   return getAO_Disarm(s);
}

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

inline u16 tMSeries::tAO_Command_1::getAO_START_Pulse(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xbfff) >> 0xe);
}

inline void tMSeries::tAO_Command_1::writeAO_START_Pulse(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_START_Pulse(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Command_1::readAO_START_Pulse(nMDBG::tStatus2* s)
{
   return getAO_START_Pulse(s);
}

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

inline u16 tMSeries::tAO_Command_1::getAO_Analog_Trigger_Reset(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0x7fff) >> 0xf);
}

inline void tMSeries::tAO_Command_1::writeAO_Analog_Trigger_Reset(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_Analog_Trigger_Reset(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Command_1::readAO_Analog_Trigger_Reset(nMDBG::tStatus2* s)
{
   return getAO_Analog_Trigger_Reset(s);
}

inline void tMSeries::tAO_Command_1::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAO_Mode_1::tAO_Mode_1()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAO_Mode_1::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAO_Mode_1::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u16 tMSeries::tAO_Mode_1::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAO_Mode_1::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u16)(0xffffffff);
}

inline void tMSeries::tAO_Mode_1::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u16 tMSeries::tAO_Mode_1::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


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

inline tBoolean tMSeries::tAO_Mode_1::getAO_Trigger_Once(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xfffe) >> 0x0);
}

inline void tMSeries::tAO_Mode_1::writeAO_Trigger_Once(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAO_Trigger_Once(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAO_Mode_1::readAO_Trigger_Once(nMDBG::tStatus2* s)
{
   return getAO_Trigger_Once(s);
}

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

inline tMSeries::tAO_Mode_1::tAO_Continuous tMSeries::tAO_Mode_1::getAO_Continuous(nMDBG::tStatus2*) const
{
   return (tAO_Continuous)((_softCopy & ~0xfffd) >> 0x1);
}

inline void tMSeries::tAO_Mode_1::writeAO_Continuous(tAO_Continuous fieldValue, nMDBG::tStatus2* s)
{
   setAO_Continuous(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_Mode_1::tAO_Continuous tMSeries::tAO_Mode_1::readAO_Continuous(nMDBG::tStatus2* s)
{
   return getAO_Continuous(s);
}

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

inline u16 tMSeries::tAO_Mode_1::getAO_UC_Switch_Load_Every_TC(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfffb) >> 0x2);
}

inline void tMSeries::tAO_Mode_1::writeAO_UC_Switch_Load_Every_TC(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_UC_Switch_Load_Every_TC(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Mode_1::readAO_UC_Switch_Load_Every_TC(nMDBG::tStatus2* s)
{
   return getAO_UC_Switch_Load_Every_TC(s);
}

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

inline tMSeries::tAO_Mode_1::tAO_UI_Source_Polarity tMSeries::tAO_Mode_1::getAO_UI_Source_Polarity(nMDBG::tStatus2*) const
{
   return (tAO_UI_Source_Polarity)((_softCopy & ~0xfff7) >> 0x3);
}

inline void tMSeries::tAO_Mode_1::writeAO_UI_Source_Polarity(tAO_UI_Source_Polarity fieldValue, nMDBG::tStatus2* s)
{
   setAO_UI_Source_Polarity(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_Mode_1::tAO_UI_Source_Polarity tMSeries::tAO_Mode_1::readAO_UI_Source_Polarity(nMDBG::tStatus2* s)
{
   return getAO_UI_Source_Polarity(s);
}

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

inline tMSeries::tAO_Mode_1::tAO_UPDATE_Source_Polarity tMSeries::tAO_Mode_1::getAO_UPDATE_Source_Polarity(nMDBG::tStatus2*) const
{
   return (tAO_UPDATE_Source_Polarity)((_softCopy & ~0xffef) >> 0x4);
}

inline void tMSeries::tAO_Mode_1::writeAO_UPDATE_Source_Polarity(tAO_UPDATE_Source_Polarity fieldValue, nMDBG::tStatus2* s)
{
   setAO_UPDATE_Source_Polarity(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_Mode_1::tAO_UPDATE_Source_Polarity tMSeries::tAO_Mode_1::readAO_UPDATE_Source_Polarity(nMDBG::tStatus2* s)
{
   return getAO_UPDATE_Source_Polarity(s);
}

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

inline tBoolean tMSeries::tAO_Mode_1::getAO_Multiple_Channels(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xffdf) >> 0x5);
}

inline void tMSeries::tAO_Mode_1::writeAO_Multiple_Channels(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAO_Multiple_Channels(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAO_Mode_1::readAO_Multiple_Channels(nMDBG::tStatus2* s)
{
   return getAO_Multiple_Channels(s);
}

inline tMSeries::tAO_Mode_1& tMSeries::tAO_Mode_1::setAO_UI_Source_Select(tAO_UI_Source_Select fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = ((u16)(_softCopy & 0xf83f)) | (((u16)fieldValue << 0x6) & ~0xf83f);
   setRegister(newValue, s);
   return *this;
}

inline tMSeries::tAO_Mode_1::tAO_UI_Source_Select tMSeries::tAO_Mode_1::getAO_UI_Source_Select(nMDBG::tStatus2*) const
{
   return (tAO_UI_Source_Select)((_softCopy & ~0xf83f) >> 0x6);
}

inline void tMSeries::tAO_Mode_1::writeAO_UI_Source_Select(tAO_UI_Source_Select fieldValue, nMDBG::tStatus2* s)
{
   setAO_UI_Source_Select(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_Mode_1::tAO_UI_Source_Select tMSeries::tAO_Mode_1::readAO_UI_Source_Select(nMDBG::tStatus2* s)
{
   return getAO_UI_Source_Select(s);
}

inline tMSeries::tAO_Mode_1& tMSeries::tAO_Mode_1::setAO_UPDATE_Source_Select(tAO_UPDATE_Source_Select fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = ((u16)(_softCopy & 0x7ff)) | (((u16)fieldValue << 0xb) & ~0x7ff);
   setRegister(newValue, s);
   return *this;
}

inline tMSeries::tAO_Mode_1::tAO_UPDATE_Source_Select tMSeries::tAO_Mode_1::getAO_UPDATE_Source_Select(nMDBG::tStatus2*) const
{
   return (tAO_UPDATE_Source_Select)((_softCopy & ~0x7ff) >> 0xb);
}

inline void tMSeries::tAO_Mode_1::writeAO_UPDATE_Source_Select(tAO_UPDATE_Source_Select fieldValue, nMDBG::tStatus2* s)
{
   setAO_UPDATE_Source_Select(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_Mode_1::tAO_UPDATE_Source_Select tMSeries::tAO_Mode_1::readAO_UPDATE_Source_Select(nMDBG::tStatus2* s)
{
   return getAO_UPDATE_Source_Select(s);
}

inline void tMSeries::tAO_Mode_1::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAO_Mode_2::tAO_Mode_2()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAO_Mode_2::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAO_Mode_2::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u16 tMSeries::tAO_Mode_2::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAO_Mode_2::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u16)(0xffffffff);
}

inline void tMSeries::tAO_Mode_2::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u16 tMSeries::tAO_Mode_2::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


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

inline u16 tMSeries::tAO_Mode_2::getAO_BC_Write_Switch(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfffe) >> 0x0);
}

inline void tMSeries::tAO_Mode_2::writeAO_BC_Write_Switch(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_BC_Write_Switch(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Mode_2::readAO_BC_Write_Switch(nMDBG::tStatus2* s)
{
   return getAO_BC_Write_Switch(s);
}

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

inline u16 tMSeries::tAO_Mode_2::getAO_BC_Reload_Mode(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfffd) >> 0x1);
}

inline void tMSeries::tAO_Mode_2::writeAO_BC_Reload_Mode(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_BC_Reload_Mode(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Mode_2::readAO_BC_Reload_Mode(nMDBG::tStatus2* s)
{
   return getAO_BC_Reload_Mode(s);
}

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

inline tMSeries::tAO_Mode_2::tAO_BC_Initial_Load_Source tMSeries::tAO_Mode_2::getAO_BC_Initial_Load_Source(nMDBG::tStatus2*) const
{
   return (tAO_BC_Initial_Load_Source)((_softCopy & ~0xfffb) >> 0x2);
}

inline void tMSeries::tAO_Mode_2::writeAO_BC_Initial_Load_Source(tAO_BC_Initial_Load_Source fieldValue, nMDBG::tStatus2* s)
{
   setAO_BC_Initial_Load_Source(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_Mode_2::tAO_BC_Initial_Load_Source tMSeries::tAO_Mode_2::readAO_BC_Initial_Load_Source(nMDBG::tStatus2* s)
{
   return getAO_BC_Initial_Load_Source(s);
}

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

inline u16 tMSeries::tAO_Mode_2::getAO_UI_Write_Switch(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfff7) >> 0x3);
}

inline void tMSeries::tAO_Mode_2::writeAO_UI_Write_Switch(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_UI_Write_Switch(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Mode_2::readAO_UI_Write_Switch(nMDBG::tStatus2* s)
{
   return getAO_UI_Write_Switch(s);
}

inline tMSeries::tAO_Mode_2& tMSeries::tAO_Mode_2::setAO_UI_Reload_Mode(tAO_UI_Reload_Mode fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = ((u16)(_softCopy & 0xff8f)) | (((u16)fieldValue << 0x4) & ~0xff8f);
   setRegister(newValue, s);
   return *this;
}

inline tMSeries::tAO_Mode_2::tAO_UI_Reload_Mode tMSeries::tAO_Mode_2::getAO_UI_Reload_Mode(nMDBG::tStatus2*) const
{
   return (tAO_UI_Reload_Mode)((_softCopy & ~0xff8f) >> 0x4);
}

inline void tMSeries::tAO_Mode_2::writeAO_UI_Reload_Mode(tAO_UI_Reload_Mode fieldValue, nMDBG::tStatus2* s)
{
   setAO_UI_Reload_Mode(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_Mode_2::tAO_UI_Reload_Mode tMSeries::tAO_Mode_2::readAO_UI_Reload_Mode(nMDBG::tStatus2* s)
{
   return getAO_UI_Reload_Mode(s);
}

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

inline tMSeries::tAO_Mode_2::tAO_UI_Initial_Load_Source tMSeries::tAO_Mode_2::getAO_UI_Initial_Load_Source(nMDBG::tStatus2*) const
{
   return (tAO_UI_Initial_Load_Source)((_softCopy & ~0xff7f) >> 0x7);
}

inline void tMSeries::tAO_Mode_2::writeAO_UI_Initial_Load_Source(tAO_UI_Initial_Load_Source fieldValue, nMDBG::tStatus2* s)
{
   setAO_UI_Initial_Load_Source(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_Mode_2::tAO_UI_Initial_Load_Source tMSeries::tAO_Mode_2::readAO_UI_Initial_Load_Source(nMDBG::tStatus2* s)
{
   return getAO_UI_Initial_Load_Source(s);
}

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

inline u16 tMSeries::tAO_Mode_2::getAO_UC_Write_Switch(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfbff) >> 0xa);
}

inline void tMSeries::tAO_Mode_2::writeAO_UC_Write_Switch(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_UC_Write_Switch(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Mode_2::readAO_UC_Write_Switch(nMDBG::tStatus2* s)
{
   return getAO_UC_Write_Switch(s);
}

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

inline tMSeries::tAO_Mode_2::tAO_UC_Initial_Load_Source tMSeries::tAO_Mode_2::getAO_UC_Initial_Load_Source(nMDBG::tStatus2*) const
{
   return (tAO_UC_Initial_Load_Source)((_softCopy & ~0xf7ff) >> 0xb);
}

inline void tMSeries::tAO_Mode_2::writeAO_UC_Initial_Load_Source(tAO_UC_Initial_Load_Source fieldValue, nMDBG::tStatus2* s)
{
   setAO_UC_Initial_Load_Source(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_Mode_2::tAO_UC_Initial_Load_Source tMSeries::tAO_Mode_2::readAO_UC_Initial_Load_Source(nMDBG::tStatus2* s)
{
   return getAO_UC_Initial_Load_Source(s);
}

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

inline u16 tMSeries::tAO_Mode_2::getAO_START1_Disable(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xefff) >> 0xc);
}

inline void tMSeries::tAO_Mode_2::writeAO_START1_Disable(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_START1_Disable(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Mode_2::readAO_START1_Disable(nMDBG::tStatus2* s)
{
   return getAO_START1_Disable(s);
}

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

inline tBoolean tMSeries::tAO_Mode_2::getAO_FIFO_Retransmit_Enable(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xdfff) >> 0xd);
}

inline void tMSeries::tAO_Mode_2::writeAO_FIFO_Retransmit_Enable(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAO_FIFO_Retransmit_Enable(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAO_Mode_2::readAO_FIFO_Retransmit_Enable(nMDBG::tStatus2* s)
{
   return getAO_FIFO_Retransmit_Enable(s);
}

inline tMSeries::tAO_Mode_2& tMSeries::tAO_Mode_2::setAO_FIFO_Mode(tAO_FIFO_Mode fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = ((u16)(_softCopy & 0x3fff)) | (((u16)fieldValue << 0xe) & ~0x3fff);
   setRegister(newValue, s);
   return *this;
}

inline tMSeries::tAO_Mode_2::tAO_FIFO_Mode tMSeries::tAO_Mode_2::getAO_FIFO_Mode(nMDBG::tStatus2*) const
{
   return (tAO_FIFO_Mode)((_softCopy & ~0x3fff) >> 0xe);
}

inline void tMSeries::tAO_Mode_2::writeAO_FIFO_Mode(tAO_FIFO_Mode fieldValue, nMDBG::tStatus2* s)
{
   setAO_FIFO_Mode(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_Mode_2::tAO_FIFO_Mode tMSeries::tAO_Mode_2::readAO_FIFO_Mode(nMDBG::tStatus2* s)
{
   return getAO_FIFO_Mode(s);
}

inline void tMSeries::tAO_Mode_2::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAO_Output_Control::tAO_Output_Control()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAO_Output_Control::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAO_Output_Control::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u16 tMSeries::tAO_Output_Control::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAO_Output_Control::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u16)(0xffffffff);
}

inline void tMSeries::tAO_Output_Control::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u16 tMSeries::tAO_Output_Control::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


inline tMSeries::tAO_Output_Control& tMSeries::tAO_Output_Control::setAO_UPDATE_Output_Select(tAO_UPDATE_Output_Select fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = ((u16)(_softCopy & 0xfffc)) | (((u16)fieldValue << 0x0) & ~0xfffc);
   setRegister(newValue, s);
   return *this;
}

inline tMSeries::tAO_Output_Control::tAO_UPDATE_Output_Select tMSeries::tAO_Output_Control::getAO_UPDATE_Output_Select(nMDBG::tStatus2*) const
{
   return (tAO_UPDATE_Output_Select)((_softCopy & ~0xfffc) >> 0x0);
}

inline void tMSeries::tAO_Output_Control::writeAO_UPDATE_Output_Select(tAO_UPDATE_Output_Select fieldValue, nMDBG::tStatus2* s)
{
   setAO_UPDATE_Output_Select(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_Output_Control::tAO_UPDATE_Output_Select tMSeries::tAO_Output_Control::readAO_UPDATE_Output_Select(nMDBG::tStatus2* s)
{
   return getAO_UPDATE_Output_Select(s);
}

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

inline tMSeries::tAO_Output_Control::tAO_External_Gate_Polarity tMSeries::tAO_Output_Control::getAO_External_Gate_Polarity(nMDBG::tStatus2*) const
{
   return (tAO_External_Gate_Polarity)((_softCopy & ~0xfff7) >> 0x3);
}

inline void tMSeries::tAO_Output_Control::writeAO_External_Gate_Polarity(tAO_External_Gate_Polarity fieldValue, nMDBG::tStatus2* s)
{
   setAO_External_Gate_Polarity(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_Output_Control::tAO_External_Gate_Polarity tMSeries::tAO_Output_Control::readAO_External_Gate_Polarity(nMDBG::tStatus2* s)
{
   return getAO_External_Gate_Polarity(s);
}

inline tMSeries::tAO_Output_Control& tMSeries::tAO_Output_Control::setAO_Number_Of_Channels(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = ((u16)(_softCopy & 0xfc3f)) | (((u16)fieldValue << 0x6) & ~0xfc3f);
   setRegister(newValue, s);
   return *this;
}

inline u16 tMSeries::tAO_Output_Control::getAO_Number_Of_Channels(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfc3f) >> 0x6);
}

inline void tMSeries::tAO_Output_Control::writeAO_Number_Of_Channels(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_Number_Of_Channels(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Output_Control::readAO_Number_Of_Channels(nMDBG::tStatus2* s)
{
   return getAO_Number_Of_Channels(s);
}

inline tMSeries::tAO_Output_Control& tMSeries::tAO_Output_Control::setAO_External_Gate_Select(tAO_External_Gate_Select fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = ((u16)(_softCopy & 0x83ff)) | (((u16)fieldValue << 0xa) & ~0x83ff);
   setRegister(newValue, s);
   return *this;
}

inline tMSeries::tAO_Output_Control::tAO_External_Gate_Select tMSeries::tAO_Output_Control::getAO_External_Gate_Select(nMDBG::tStatus2*) const
{
   return (tAO_External_Gate_Select)((_softCopy & ~0x83ff) >> 0xa);
}

inline void tMSeries::tAO_Output_Control::writeAO_External_Gate_Select(tAO_External_Gate_Select fieldValue, nMDBG::tStatus2* s)
{
   setAO_External_Gate_Select(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_Output_Control::tAO_External_Gate_Select tMSeries::tAO_Output_Control::readAO_External_Gate_Select(nMDBG::tStatus2* s)
{
   return getAO_External_Gate_Select(s);
}

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

inline u16 tMSeries::tAO_Output_Control::getAO_External_Gate_Enable(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0x7fff) >> 0xf);
}

inline void tMSeries::tAO_Output_Control::writeAO_External_Gate_Enable(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_External_Gate_Enable(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Output_Control::readAO_External_Gate_Enable(nMDBG::tStatus2* s)
{
   return getAO_External_Gate_Enable(s);
}

inline void tMSeries::tAO_Output_Control::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAO_Mode_3::tAO_Mode_3()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAO_Mode_3::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAO_Mode_3::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u16 tMSeries::tAO_Mode_3::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAO_Mode_3::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u16)(0xffffffff);
}

inline void tMSeries::tAO_Mode_3::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u16 tMSeries::tAO_Mode_3::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


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

inline u16 tMSeries::tAO_Mode_3::getAO_Last_Gate_Disable(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfffe) >> 0x0);
}

inline void tMSeries::tAO_Mode_3::writeAO_Last_Gate_Disable(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_Last_Gate_Disable(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Mode_3::readAO_Last_Gate_Disable(nMDBG::tStatus2* s)
{
   return getAO_Last_Gate_Disable(s);
}

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

inline u16 tMSeries::tAO_Mode_3::getAO_Software_Gate(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfffd) >> 0x1);
}

inline void tMSeries::tAO_Mode_3::writeAO_Software_Gate(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_Software_Gate(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Mode_3::readAO_Software_Gate(nMDBG::tStatus2* s)
{
   return getAO_Software_Gate(s);
}

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

inline u16 tMSeries::tAO_Mode_3::getAO_Not_An_UPDATE(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfffb) >> 0x2);
}

inline void tMSeries::tAO_Mode_3::writeAO_Not_An_UPDATE(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_Not_An_UPDATE(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Mode_3::readAO_Not_An_UPDATE(nMDBG::tStatus2* s)
{
   return getAO_Not_An_UPDATE(s);
}

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

inline tBoolean tMSeries::tAO_Mode_3::getAO_Stop_On_BC_TC_Error(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xfff7) >> 0x3);
}

inline void tMSeries::tAO_Mode_3::writeAO_Stop_On_BC_TC_Error(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAO_Stop_On_BC_TC_Error(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAO_Mode_3::readAO_Stop_On_BC_TC_Error(nMDBG::tStatus2* s)
{
   return getAO_Stop_On_BC_TC_Error(s);
}

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

inline tBoolean tMSeries::tAO_Mode_3::getAO_Stop_On_BC_TC_Trigger_Error(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xffef) >> 0x4);
}

inline void tMSeries::tAO_Mode_3::writeAO_Stop_On_BC_TC_Trigger_Error(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAO_Stop_On_BC_TC_Trigger_Error(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAO_Mode_3::readAO_Stop_On_BC_TC_Trigger_Error(nMDBG::tStatus2* s)
{
   return getAO_Stop_On_BC_TC_Trigger_Error(s);
}

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

inline tBoolean tMSeries::tAO_Mode_3::getAO_Stop_On_Overrun_Error(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xffdf) >> 0x5);
}

inline void tMSeries::tAO_Mode_3::writeAO_Stop_On_Overrun_Error(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAO_Stop_On_Overrun_Error(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAO_Mode_3::readAO_Stop_On_Overrun_Error(nMDBG::tStatus2* s)
{
   return getAO_Stop_On_Overrun_Error(s);
}

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

inline tMSeries::tAO_Mode_3::tAO_Trigger_Length tMSeries::tAO_Mode_3::getAO_Trigger_Length(nMDBG::tStatus2*) const
{
   return (tAO_Trigger_Length)((_softCopy & ~0xf7ff) >> 0xb);
}

inline void tMSeries::tAO_Mode_3::writeAO_Trigger_Length(tAO_Trigger_Length fieldValue, nMDBG::tStatus2* s)
{
   setAO_Trigger_Length(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_Mode_3::tAO_Trigger_Length tMSeries::tAO_Mode_3::readAO_Trigger_Length(nMDBG::tStatus2* s)
{
   return getAO_Trigger_Length(s);
}

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

inline u16 tMSeries::tAO_Mode_3::getAO_UC_Switch_Load_Every_BC_TC(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xefff) >> 0xc);
}

inline void tMSeries::tAO_Mode_3::writeAO_UC_Switch_Load_Every_BC_TC(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_UC_Switch_Load_Every_BC_TC(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_Mode_3::readAO_UC_Switch_Load_Every_BC_TC(nMDBG::tStatus2* s)
{
   return getAO_UC_Switch_Load_Every_BC_TC(s);
}

inline void tMSeries::tAO_Mode_3::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAO_Personal::tAO_Personal()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAO_Personal::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAO_Personal::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u16 tMSeries::tAO_Personal::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAO_Personal::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u16)(0xffffffff);
}

inline void tMSeries::tAO_Personal::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u16 tMSeries::tAO_Personal::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


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

inline tBoolean tMSeries::tAO_Personal::getAO_Interval_Buffer_Mode(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xfff7) >> 0x3);
}

inline void tMSeries::tAO_Personal::writeAO_Interval_Buffer_Mode(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAO_Interval_Buffer_Mode(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAO_Personal::readAO_Interval_Buffer_Mode(nMDBG::tStatus2* s)
{
   return getAO_Interval_Buffer_Mode(s);
}

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

inline tMSeries::tAO_Personal::tAO_BC_Source_Select tMSeries::tAO_Personal::getAO_BC_Source_Select(nMDBG::tStatus2*) const
{
   return (tAO_BC_Source_Select)((_softCopy & ~0xffef) >> 0x4);
}

inline void tMSeries::tAO_Personal::writeAO_BC_Source_Select(tAO_BC_Source_Select fieldValue, nMDBG::tStatus2* s)
{
   setAO_BC_Source_Select(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_Personal::tAO_BC_Source_Select tMSeries::tAO_Personal::readAO_BC_Source_Select(nMDBG::tStatus2* s)
{
   return getAO_BC_Source_Select(s);
}

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

inline tMSeries::tAO_Personal::tAO_UPDATE_Pulse_Width tMSeries::tAO_Personal::getAO_UPDATE_Pulse_Width(nMDBG::tStatus2*) const
{
   return (tAO_UPDATE_Pulse_Width)((_softCopy & ~0xffdf) >> 0x5);
}

inline void tMSeries::tAO_Personal::writeAO_UPDATE_Pulse_Width(tAO_UPDATE_Pulse_Width fieldValue, nMDBG::tStatus2* s)
{
   setAO_UPDATE_Pulse_Width(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_Personal::tAO_UPDATE_Pulse_Width tMSeries::tAO_Personal::readAO_UPDATE_Pulse_Width(nMDBG::tStatus2* s)
{
   return getAO_UPDATE_Pulse_Width(s);
}

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

inline tMSeries::tAO_Personal::tAO_UPDATE_Pulse_Timebase tMSeries::tAO_Personal::getAO_UPDATE_Pulse_Timebase(nMDBG::tStatus2*) const
{
   return (tAO_UPDATE_Pulse_Timebase)((_softCopy & ~0xffbf) >> 0x6);
}

inline void tMSeries::tAO_Personal::writeAO_UPDATE_Pulse_Timebase(tAO_UPDATE_Pulse_Timebase fieldValue, nMDBG::tStatus2* s)
{
   setAO_UPDATE_Pulse_Timebase(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_Personal::tAO_UPDATE_Pulse_Timebase tMSeries::tAO_Personal::readAO_UPDATE_Pulse_Timebase(nMDBG::tStatus2* s)
{
   return getAO_UPDATE_Pulse_Timebase(s);
}

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

inline tMSeries::tAO_Personal::tAO_UPDATE_Original_Pulse tMSeries::tAO_Personal::getAO_UPDATE_Original_Pulse(nMDBG::tStatus2*) const
{
   return (tAO_UPDATE_Original_Pulse)((_softCopy & ~0xff7f) >> 0x7);
}

inline void tMSeries::tAO_Personal::writeAO_UPDATE_Original_Pulse(tAO_UPDATE_Original_Pulse fieldValue, nMDBG::tStatus2* s)
{
   setAO_UPDATE_Original_Pulse(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_Personal::tAO_UPDATE_Original_Pulse tMSeries::tAO_Personal::readAO_UPDATE_Original_Pulse(nMDBG::tStatus2* s)
{
   return getAO_UPDATE_Original_Pulse(s);
}

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

inline tBoolean tMSeries::tAO_Personal::getAO_FIFO_Enable(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xfbff) >> 0xa);
}

inline void tMSeries::tAO_Personal::writeAO_FIFO_Enable(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAO_FIFO_Enable(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAO_Personal::readAO_FIFO_Enable(nMDBG::tStatus2* s)
{
   return getAO_FIFO_Enable(s);
}

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

inline tMSeries::tAO_Personal::tAO_TMRDACWR_Pulse_Width tMSeries::tAO_Personal::getAO_TMRDACWR_Pulse_Width(nMDBG::tStatus2*) const
{
   return (tAO_TMRDACWR_Pulse_Width)((_softCopy & ~0xefff) >> 0xc);
}

inline void tMSeries::tAO_Personal::writeAO_TMRDACWR_Pulse_Width(tAO_TMRDACWR_Pulse_Width fieldValue, nMDBG::tStatus2* s)
{
   setAO_TMRDACWR_Pulse_Width(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_Personal::tAO_TMRDACWR_Pulse_Width tMSeries::tAO_Personal::readAO_TMRDACWR_Pulse_Width(nMDBG::tStatus2* s)
{
   return getAO_TMRDACWR_Pulse_Width(s);
}

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

inline tMSeries::tAO_Personal::tAO_Number_Of_DAC_Packages tMSeries::tAO_Personal::getAO_Number_Of_DAC_Packages(nMDBG::tStatus2*) const
{
   return (tAO_Number_Of_DAC_Packages)((_softCopy & ~0xbfff) >> 0xe);
}

inline void tMSeries::tAO_Personal::writeAO_Number_Of_DAC_Packages(tAO_Number_Of_DAC_Packages fieldValue, nMDBG::tStatus2* s)
{
   setAO_Number_Of_DAC_Packages(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_Personal::tAO_Number_Of_DAC_Packages tMSeries::tAO_Personal::readAO_Number_Of_DAC_Packages(nMDBG::tStatus2* s)
{
   return getAO_Number_Of_DAC_Packages(s);
}

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

inline tBoolean tMSeries::tAO_Personal::getAO_Multiple_DACS_Per_Package(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0x7fff) >> 0xf);
}

inline void tMSeries::tAO_Personal::writeAO_Multiple_DACS_Per_Package(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAO_Multiple_DACS_Per_Package(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAO_Personal::readAO_Multiple_DACS_Per_Package(nMDBG::tStatus2* s)
{
   return getAO_Multiple_DACS_Per_Package(s);
}

inline void tMSeries::tAO_Personal::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAO_START_Select::tAO_START_Select()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAO_START_Select::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAO_START_Select::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u16 tMSeries::tAO_START_Select::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAO_START_Select::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u16)(0xffffffff);
}

inline void tMSeries::tAO_START_Select::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u16 tMSeries::tAO_START_Select::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


inline tMSeries::tAO_START_Select& tMSeries::tAO_START_Select::set(tDefault fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = ((u16)(_softCopy & 0xffe0)) | (((u16)fieldValue << 0x0) & ~0xffe0);
   setRegister(newValue, s);
   return *this;
}

inline tMSeries::tAO_START_Select::tDefault tMSeries::tAO_START_Select::get(nMDBG::tStatus2*) const
{
   return (tDefault)((_softCopy & ~0xffe0) >> 0x0);
}

inline void tMSeries::tAO_START_Select::write(tDefault fieldValue, nMDBG::tStatus2* s)
{
   set(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_START_Select::tDefault tMSeries::tAO_START_Select::read(nMDBG::tStatus2* s)
{
   return get(s);
}

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

inline u16 tMSeries::tAO_START_Select::getAO_START_Edge(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xffdf) >> 0x5);
}

inline void tMSeries::tAO_START_Select::writeAO_START_Edge(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_START_Edge(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_START_Select::readAO_START_Edge(nMDBG::tStatus2* s)
{
   return getAO_START_Edge(s);
}

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

inline u16 tMSeries::tAO_START_Select::getAO_START_Sync(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xffbf) >> 0x6);
}

inline void tMSeries::tAO_START_Select::writeAO_START_Sync(u16 fieldValue, nMDBG::tStatus2* s)
{
   setAO_START_Sync(fieldValue, s);
   flush(s);
}
inline u16 tMSeries::tAO_START_Select::readAO_START_Sync(nMDBG::tStatus2* s)
{
   return getAO_START_Sync(s);
}

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

inline tBoolean tMSeries::tAO_START_Select::getAO_AOFREQ_Enable(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xefff) >> 0xc);
}

inline void tMSeries::tAO_START_Select::writeAO_AOFREQ_Enable(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAO_AOFREQ_Enable(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAO_START_Select::readAO_AOFREQ_Enable(nMDBG::tStatus2* s)
{
   return getAO_AOFREQ_Enable(s);
}

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

inline tMSeries::tAO_START_Select::tAO_START_Polarity tMSeries::tAO_START_Select::getAO_START_Polarity(nMDBG::tStatus2*) const
{
   return (tAO_START_Polarity)((_softCopy & ~0xdfff) >> 0xd);
}

inline void tMSeries::tAO_START_Select::writeAO_START_Polarity(tAO_START_Polarity fieldValue, nMDBG::tStatus2* s)
{
   setAO_START_Polarity(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_START_Select::tAO_START_Polarity tMSeries::tAO_START_Select::readAO_START_Polarity(nMDBG::tStatus2* s)
{
   return getAO_START_Polarity(s);
}

inline void tMSeries::tAO_START_Select::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAO_Status_2::tAO_Status_2()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAO_Status_2::registerMap(void)
{
   return _MSeries;
}

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

inline u16 tMSeries::tAO_Status_2::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

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

inline u16 tMSeries::tAO_Status_2::getAO_BC_Armed_St(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfffe) >> 0x0);
}

inline u16 tMSeries::tAO_Status_2::readAO_BC_Armed_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_BC_Armed_St(s);
}

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

inline u16 tMSeries::tAO_Status_2::getAO_BC_Save_St(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfffb) >> 0x2);
}

inline u16 tMSeries::tAO_Status_2::readAO_BC_Save_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_BC_Save_St(s);
}

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

inline u16 tMSeries::tAO_Status_2::getAO_BC_Q_St(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfff7) >> 0x3);
}

inline u16 tMSeries::tAO_Status_2::readAO_BC_Q_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_BC_Q_St(s);
}

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

inline u16 tMSeries::tAO_Status_2::getAO_BC_TC_Trigger_Error_St(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xffef) >> 0x4);
}

inline u16 tMSeries::tAO_Status_2::readAO_BC_TC_Trigger_Error_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_BC_TC_Trigger_Error_St(s);
}

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

inline u16 tMSeries::tAO_Status_2::getAO_UI_Armed_St(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xffdf) >> 0x5);
}

inline u16 tMSeries::tAO_Status_2::readAO_UI_Armed_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_UI_Armed_St(s);
}

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

inline u16 tMSeries::tAO_Status_2::getAO_UI_Next_Load_Source_St(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xffbf) >> 0x6);
}

inline u16 tMSeries::tAO_Status_2::readAO_UI_Next_Load_Source_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_UI_Next_Load_Source_St(s);
}

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

inline u16 tMSeries::tAO_Status_2::getAO_UC_Save_St(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xff7f) >> 0x7);
}

inline u16 tMSeries::tAO_Status_2::readAO_UC_Save_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_UC_Save_St(s);
}

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

inline u16 tMSeries::tAO_Status_2::getAO_UI_Count_Enabled_St(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfeff) >> 0x8);
}

inline u16 tMSeries::tAO_Status_2::readAO_UI_Count_Enabled_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_UI_Count_Enabled_St(s);
}

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

inline u16 tMSeries::tAO_Status_2::getAO_UI_Q_St(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfdff) >> 0x9);
}

inline u16 tMSeries::tAO_Status_2::readAO_UI_Q_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_UI_Q_St(s);
}

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

inline u16 tMSeries::tAO_Status_2::getAO_UC_Armed_St(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xbfff) >> 0xe);
}

inline u16 tMSeries::tAO_Status_2::readAO_UC_Armed_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_UC_Armed_St(s);
}

inline void tMSeries::tAO_Status_2::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAO_Status_1::tAO_Status_1()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAO_Status_1::registerMap(void)
{
   return _MSeries;
}

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

inline u16 tMSeries::tAO_Status_1::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

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

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

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

inline u16 tMSeries::tAO_Status_1::getPass_Thru_1_Interrupt_St(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfffe) >> 0x0);
}

inline u16 tMSeries::tAO_Status_1::readPass_Thru_1_Interrupt_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getPass_Thru_1_Interrupt_St(s);
}

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

inline u16 tMSeries::tAO_Status_1::getAO_FIFO_Request_St(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfffd) >> 0x1);
}

inline u16 tMSeries::tAO_Status_1::readAO_FIFO_Request_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_FIFO_Request_St(s);
}

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

inline u16 tMSeries::tAO_Status_1::getG1_Gate_Interrupt_St(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfffb) >> 0x2);
}

inline u16 tMSeries::tAO_Status_1::readG1_Gate_Interrupt_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getG1_Gate_Interrupt_St(s);
}

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

inline u16 tMSeries::tAO_Status_1::getG1_TC_St(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfff7) >> 0x3);
}

inline u16 tMSeries::tAO_Status_1::readG1_TC_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getG1_TC_St(s);
}

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

inline u16 tMSeries::tAO_Status_1::getAO_UPDATE_St(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xffdf) >> 0x5);
}

inline u16 tMSeries::tAO_Status_1::readAO_UPDATE_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_UPDATE_St(s);
}

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

inline u16 tMSeries::tAO_Status_1::getAO_UC_TC_St(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xffbf) >> 0x6);
}

inline u16 tMSeries::tAO_Status_1::readAO_UC_TC_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_UC_TC_St(s);
}

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

inline u16 tMSeries::tAO_Status_1::getAO_BC_TC_St(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xff7f) >> 0x7);
}

inline u16 tMSeries::tAO_Status_1::readAO_BC_TC_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_BC_TC_St(s);
}

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

inline u16 tMSeries::tAO_Status_1::getAO_START1_St(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfeff) >> 0x8);
}

inline u16 tMSeries::tAO_Status_1::readAO_START1_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_START1_St(s);
}

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

inline u16 tMSeries::tAO_Status_1::getAO_Overrun_St(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfdff) >> 0x9);
}

inline u16 tMSeries::tAO_Status_1::readAO_Overrun_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_Overrun_St(s);
}

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

inline u16 tMSeries::tAO_Status_1::getAO_START_St(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xfbff) >> 0xa);
}

inline u16 tMSeries::tAO_Status_1::readAO_START_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_START_St(s);
}

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

inline u16 tMSeries::tAO_Status_1::getAO_BC_TC_Error_St(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xf7ff) >> 0xb);
}

inline u16 tMSeries::tAO_Status_1::readAO_BC_TC_Error_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_BC_TC_Error_St(s);
}

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

inline u16 tMSeries::tAO_Status_1::getAO_FIFO_Empty_St(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xefff) >> 0xc);
}

inline u16 tMSeries::tAO_Status_1::readAO_FIFO_Empty_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_FIFO_Empty_St(s);
}

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

inline u16 tMSeries::tAO_Status_1::getAO_FIFO_Half_Full_St(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xdfff) >> 0xd);
}

inline u16 tMSeries::tAO_Status_1::readAO_FIFO_Half_Full_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_FIFO_Half_Full_St(s);
}

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

inline u16 tMSeries::tAO_Status_1::getAO_FIFO_Full_St(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0xbfff) >> 0xe);
}

inline u16 tMSeries::tAO_Status_1::readAO_FIFO_Full_St(nMDBG::tStatus2* s)
{
   refresh(s);
   return getAO_FIFO_Full_St(s);
}

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

inline u16 tMSeries::tAO_Status_1::getInterrupt_Group_B_Status(nMDBG::tStatus2*) const
{
   return (u16)((_softCopy & ~0x7fff) >> 0xf);
}

inline u16 tMSeries::tAO_Status_1::readInterrupt_Group_B_Status(nMDBG::tStatus2* s)
{
   refresh(s);
   return getInterrupt_Group_B_Status(s);
}

inline void tMSeries::tAO_Status_1::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAO_Trigger_Select::tAO_Trigger_Select()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAO_Trigger_Select::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAO_Trigger_Select::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u16 tMSeries::tAO_Trigger_Select::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAO_Trigger_Select::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u16)(0xffffffff);
}

inline void tMSeries::tAO_Trigger_Select::writeRegister(u16 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u16 tMSeries::tAO_Trigger_Select::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


inline tMSeries::tAO_Trigger_Select& tMSeries::tAO_Trigger_Select::setAO_START1_Select(tAO_START1_Select fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return *this;
   u16 newValue;   newValue = ((u16)(_softCopy & 0xffe0)) | (((u16)fieldValue << 0x0) & ~0xffe0);
   setRegister(newValue, s);
   return *this;
}

inline tMSeries::tAO_Trigger_Select::tAO_START1_Select tMSeries::tAO_Trigger_Select::getAO_START1_Select(nMDBG::tStatus2*) const
{
   return (tAO_START1_Select)((_softCopy & ~0xffe0) >> 0x0);
}

inline void tMSeries::tAO_Trigger_Select::writeAO_START1_Select(tAO_START1_Select fieldValue, nMDBG::tStatus2* s)
{
   setAO_START1_Select(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_Trigger_Select::tAO_START1_Select tMSeries::tAO_Trigger_Select::readAO_START1_Select(nMDBG::tStatus2* s)
{
   return getAO_START1_Select(s);
}

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

inline tBoolean tMSeries::tAO_Trigger_Select::getAO_START1_Edge(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xffdf) >> 0x5);
}

inline void tMSeries::tAO_Trigger_Select::writeAO_START1_Edge(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAO_START1_Edge(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAO_Trigger_Select::readAO_START1_Edge(nMDBG::tStatus2* s)
{
   return getAO_START1_Edge(s);
}

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

inline tBoolean tMSeries::tAO_Trigger_Select::getAO_START1_Sync(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xffbf) >> 0x6);
}

inline void tMSeries::tAO_Trigger_Select::writeAO_START1_Sync(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAO_START1_Sync(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAO_Trigger_Select::readAO_START1_Sync(nMDBG::tStatus2* s)
{
   return getAO_START1_Sync(s);
}

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

inline tMSeries::tAO_Trigger_Select::tAO_START1_Polarity tMSeries::tAO_Trigger_Select::getAO_START1_Polarity(nMDBG::tStatus2*) const
{
   return (tAO_START1_Polarity)((_softCopy & ~0xdfff) >> 0xd);
}

inline void tMSeries::tAO_Trigger_Select::writeAO_START1_Polarity(tAO_START1_Polarity fieldValue, nMDBG::tStatus2* s)
{
   setAO_START1_Polarity(fieldValue, s);
   flush(s);
}
inline tMSeries::tAO_Trigger_Select::tAO_START1_Polarity tMSeries::tAO_Trigger_Select::readAO_START1_Polarity(nMDBG::tStatus2* s)
{
   return getAO_START1_Polarity(s);
}

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

inline tBoolean tMSeries::tAO_Trigger_Select::getAO_Delayed_START1(nMDBG::tStatus2*) const
{
   return (tBoolean)((_softCopy & ~0xbfff) >> 0xe);
}

inline void tMSeries::tAO_Trigger_Select::writeAO_Delayed_START1(tBoolean fieldValue, nMDBG::tStatus2* s)
{
   setAO_Delayed_START1(fieldValue, s);
   flush(s);
}
inline tBoolean tMSeries::tAO_Trigger_Select::readAO_Delayed_START1(nMDBG::tStatus2* s)
{
   return getAO_Delayed_START1(s);
}

inline void tMSeries::tAO_Trigger_Select::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAO_UC_Load_A::tAO_UC_Load_A()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAO_UC_Load_A::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAO_UC_Load_A::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

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

inline u32 tMSeries::tAO_UC_Load_A::getRegister(nMDBG::tStatus2*) const
{
   return _softCopy;
}

inline void tMSeries::tAO_UC_Load_A::flush(nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   tIOStrategy::write(_MSeries->getBusSpaceReference(), kOffset + _MSeries->getAddressOffset(s), _softCopy, s);
   _softCopy &= (u32)(0xffffffff);
}

inline void tMSeries::tAO_UC_Load_A::writeRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->isFatal()) return;
   _softCopy = fieldValue;
   flush(s);
}

inline u32 tMSeries::tAO_UC_Load_A::readRegister(nMDBG::tStatus2*) 
{
   return _softCopy;
}


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

inline u32 tMSeries::tAO_UC_Load_A::get(nMDBG::tStatus2*) const
{
   return (u32)((_softCopy & ~0x0) >> 0x0);
}

inline void tMSeries::tAO_UC_Load_A::write(u32 fieldValue, nMDBG::tStatus2* s)
{
   set(fieldValue, s);
   flush(s);
}
inline u32 tMSeries::tAO_UC_Load_A::read(nMDBG::tStatus2* s)
{
   return get(s);
}

inline void tMSeries::tAO_UC_Load_A::setRegisterMap(tMSeries* pMSeries)
{
   _MSeries = pMSeries;
}

inline tMSeries::tAO_UC_Load_B::tAO_UC_Load_B()
{
   _softCopy = 0;
}

inline tMSeries* tMSeries::tAO_UC_Load_B::registerMap(void)
{
   return _MSeries;
}

inline void tMSeries::tAO_UC_Load_B::flushBus(nMDBG::tStatus2* s)
{
   _MSeries->flushBus(s);
}

inline tMSeries::tAO_UC_Load_B& tMSeries::tAO_UC_Load_B::setRegister(u32 fieldValue, nMDBG::tStatus2* s)
{
   if (s && s->