using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace LampInspectionMachine.KHLplc
{

    class KvStruct
    {
        const int stMemArr_WSIZE = 150;
        const int stNode_WSIZE = 22;
        const int stParent_WSIZE = 244;
        const int _ACCESS_WINDOW_WSIZE = 24;
        const int _AUTOLOAD_CTRL_WSIZE = 5;
        const int _CPU_MEMORY_SAVE_WSIZE = 1;
        const int _DEV_INFO_WSIZE = 4;
        const int _EC_MASTER_WSIZE = 772;
        const int _EC_NODE_WSIZE = 28;
        const int _ERROR_CTRL_WSIZE = 1;
        const int _ERROR_DETAIL_WSIZE = 27;
        const int _EXPANSION_UNIT_WSIZE = 76;
        const int _FILE_INFO_WSIZE = 76;
        const int _FILE_STATUS_WSIZE = 10;
        const int _LOGGING_TRACE_WSIZE = 10;
        const int _MC_AXIS_CFG_WSIZE = 100;
        const int _MC_AXIS_CMP_CODE_WSIZE = 24;
        const int _MC_AXIS_CTRL_WSIZE = 100;
        const int _MC_AXIS_GROUP_CFG_WSIZE = 16;
        const int _MC_AXIS_GROUP_REF_WSIZE = 1;
        const int _MC_AXIS_IO_STATUS_WSIZE = 1;
        const int _MC_AXIS_MOTION_FUNC_MAP_WSIZE = 2;
        const int _MC_AXIS_REF_WSIZE = 226;
        const int _MC_AXIS_STATUS_WSIZE = 112;
        const int _MC_AXIS_STATUS_BIT_WSIZE = 8;
        const int _MC_AXIS_SYNC_STATUS_WSIZE = 80;
        const int _MC_CAM_SECTION_WSIZE = 12;
        const int _MC_COMMON_WSIZE = 64;
        const int _MC_COMMON_CFG_WSIZE = 386;
        const int _MC_COMMON_CMP_CODE_WSIZE = 8;
        const int _MC_COMMON_CTRL_WSIZE = 96;
        const int _MC_COMMON_PERFORMANCE_WSIZE = 12;
        const int _MC_COMMON_STATUS_WSIZE = 40;
        const int _MC_COMMON_STATUS_BIT_WSIZE = 4;
        const int _MC_POINT_PARAM_WSIZE = 40;
        const int _MC_POINT_PARAM_AXIS_WSIZE = 2000;
        const int _MC_POS_CFG_WSIZE = 200;
        const int _MC_SYNC_CONTACT_OUTPUT_WSIZE = 1;
        const int _MC_SYNC_CONTACT_OUTPUT_CFG_WSIZE = 384;
        const int _MC_SYNC_CONTACT_OUTPUT_SUB_CFG_WSIZE = 12;
        const int _MC_SYNC_EXT_INPUT_CFG_WSIZE = 8;
        const int _MC_SYNC_PARAM_WSIZE = 200;
        const int _OPERATION_RECORDER_WSIZE = 200;
        const int _PROGRAM_INFO_WSIZE = 26;
        const int _PROJECT_INFO_WSIZE = 46;
        const int _PROJECT_RECIPE_SAVE_LOAD_WSIZE = 6;
        const int _RECIPE_SAVE_WSIZE = 6;
        const int _SOCKET_STATUS_WSIZE = 12;
        const int _STORAGE_WSIZE = 82;
        const int _STRING_TO_VARIABLE_PARAM_WSIZE = 2;
        const int _UNIT_ID_ADR_WSIZE = 6;
        const int _UNIT_SYNCHRONIZE_WSIZE = 12;
        const int _VARIABLE_TO_STRING_PARAM_WSIZE = 4;


        public class stMemArr
        {
            public ushort[,] auSample = new ushort[10,10];
            public byte[,] astrSample = new byte[10,10];
        }

        public class stNode
        {
            public bool xMember = default(bool);
            public bool xMember2 = default(bool);
            public ushort uMember = default(ushort);
            public short iMember = default(short);
            public uint duMember = default(uint);
            public int diMember = default(int);
            public float fMember = default(float);
            public double dfMember = default(double);
            public byte[] strMember = new byte[16];
        }

        public class stParent
        {
            public bool xReq = default(bool);
            public bool xCmp = default(bool);
            public bool xErr = default(bool);
            public ushort uErrCode = default(ushort);
            public stNode stNode_Member = new stNode();
            public stNode[] astNode = (stNode[])CreateClassInstanceArray<stNode>(new int[1] {10});
        }

        public class _ACCESS_WINDOW
        {
            public bool UpKeyPressed = default(bool);
            public bool DownKeyPressed = default(bool);
            public bool LeftKeyPressed = default(bool);
            public bool RightKeyPressed = default(bool);
            public bool MenuKeyPressed = default(bool);
            public bool EnterKeyPressed = default(bool);
            public bool UserMessageDisplayed = default(bool);
            public bool[] BlinkLine = new bool[4];
            public bool[] DisplayUserMessage = new bool[63];
            public ushort UserMessageDisplayID = default(ushort);
            public ushort InitialDispLangSetting = default(ushort);
            public ushort InitialCommentNumberSetting = default(ushort);
            public ushort WindowOperationDisable = default(ushort);
            public ushort InitScreenSetValid = default(ushort);
            public ushort InitScreenSetDeviceType = default(ushort);
            public uint InitScreenSetScreenID = default(uint);
            public uint InitScreenSetDeviceNumber = default(uint);
            public ushort InitScreenSetDisplayFormat = default(ushort);
            public ushort InitScreenSetDeviceDisplay = default(ushort);
            public ushort InitScreenSetKeyLockStatus = default(ushort);
            public ushort[] Reserved = new ushort[1];
        }

        public class _AUTOLOAD_CTRL
        {
            public ushort FolderNumber = default(ushort);
            public ushort CompleteFolderNumber = default(ushort);
            public ushort FinCode = default(ushort);
        }

        public class _CPU_MEMORY_SAVE
        {
            public bool Request = default(bool);
            public bool Busy = default(bool);
            public bool Complete = default(bool);
            public bool Error = default(bool);
        }

        public class _DEV_INFO
        {
            public ushort DevType = default(ushort);
            public ushort BitOffset = default(ushort);
            public uint DevNo = default(uint);
        }

        public class _EC_MASTER
        {
            public bool MasterError = default(bool);
            public bool PDOActive = default(bool);
            public bool PDOInactive = default(bool);
            public bool PDOCommError = default(bool);
            public bool RingError = default(bool);
            public bool InDataInvalid = default(bool);
            public bool[] PDOParticipationTbl = new bool[512];
            public bool[] PDOActiveTbl = new bool[512];
            public bool[] PDOCommErrorTbl = new bool[512];
            public bool[] SDOActiveTbl = new bool[512];
            public bool[] RegTbl = new bool[512];
            public bool[] ReserveTbl = new bool[512];
            public bool[] PDOStopReqTbl = new bool[512];
            public bool[] RingErrorTbl = new bool[512];
            public ushort[] EcStateTbl = new ushort[512];
            public ushort MasterErrorCode = default(ushort);
            public ushort MasterErrorDetail1 = default(ushort);
            public ushort MasterErrorDetail2 = default(ushort);
        }

        public class _EC_NODE
        {
            public uint VenderID = default(uint);
            public uint ProductCode = default(uint);
            public uint RevisionNo = default(uint);
            public uint SerialNo = default(uint);
            public ushort StationAlias = default(ushort);
            public ushort[] ConnectNodeNo = new ushort[4];
            public ushort[] RxErrorCount = new ushort[4];
            public ushort EmgMsgErrorCode = default(ushort);
            public ushort EmgMsgErrorReg = default(ushort);
            public ushort EmgMsgData0_1 = default(ushort);
            public ushort EmgMsgData2_3 = default(ushort);
            public ushort EmgMsgData4 = default(ushort);
            public ushort NodeErrorCode = default(ushort);
            public ushort NodeErrorDetail1 = default(ushort);
            public ushort NodeErrorDetail2 = default(ushort);
            public ushort NodeWarning = default(ushort);
            public bool NodeError = default(bool);
        }

        public class _ERROR_CTRL
        {
            public bool Error = default(bool);
            public bool Warning = default(bool);
            public bool ClearCurrentError = default(bool);
            public bool ClearHistory = default(bool);
        }

        public class _ERROR_DETAIL
        {
            public ushort YearMonth = default(ushort);
            public ushort Day = default(ushort);
            public ushort Hour = default(ushort);
            public ushort Minute = default(ushort);
            public ushort Second = default(ushort);
            public ushort ErrorNumber = default(ushort);
            public ushort ValidCount = default(ushort);
            public ushort[] Detail = new ushort[20];
        }

        public class _EXPANSION_UNIT
        {
            public bool[] Connected = new bool[49];
            public bool[] LoadOption = new bool[49];
            public ushort UnitNumber = default(ushort);
        }

        public class _FILE_STATUS
        {
            public ushort[] ModifiedDate = new ushort[6];
            public uint FileSize = default(uint);
            public bool ReadOnly = default(bool);
            public bool HiddenFile = default(bool);
            public bool SystemFile = default(bool);
            public bool VolumeLabel = default(bool);
            public bool Folder = default(bool);
            public bool Archive = default(bool);
            public ushort[] Reserved = new ushort[1];
        }

        public class _LOGGING_TRACE
        {
            public bool ExecEnable = default(bool);
            public bool InOperation = default(bool);
            public bool FileWriteEnd = default(bool);
            public bool BufferHalfAlm = default(bool);
            public bool BufferOverflow = default(bool);
            public bool WriteDuringRun = default(bool);
            public bool LoggingTraceError = default(bool);
            public bool NoMemoryCapacity = default(bool);
            public bool DeviceTriggerSetError = default(bool);
            public bool FileSaveTriggerMonitor = default(bool);
            public bool DataAcquireComplete = default(bool);
            public ushort MinBufferSpace = default(ushort);
            public ushort LoopBufferSpace = default(ushort);
            public ushort FileSavingCounter = default(ushort);
            public ushort[] Reserved = new ushort[6];
        }

        public class _MC_AXIS_CFG
        {
            public ushort UnitCoordTrans = default(ushort);
            public double PosCycle = default(double);
            public uint CoordTransDenominator = default(uint);
            public uint CoordTransNumerator = default(uint);
            public ushort SoftLimitCoordSystem = default(ushort);
            public ushort UseSoftLimit = default(ushort);
            public double SoftLimitPositivePos = default(double);
            public double SoftLimitNegativePos = default(double);
            public ushort AxisErrorSetting = default(ushort);
            public ushort AxisCtrlSetting = default(ushort);
            public ushort ServoEndCheckTime = default(ushort);
            public double BacklashCompensationMovement = default(double);
            public double ServoEndRange = default(double);
            public ushort ChgToPosCtrlModeVelThresh = default(ushort);
            public int AbsEncUpperLim = default(int);
            public int AbsEncLowerLim = default(int);
            public ushort[] Reserved = new ushort[54];
        }

        public class _MC_AXIS_CMP_CODE
        {
            public ushort PosCtrlStart = default(ushort);
            public ushort SetPosition = default(ushort);
            public ushort ChgTargetPos = default(ushort);
            public ushort ChgTargetVel = default(ushort);
            public ushort Stop = default(ushort);
            public ushort RestartPositioning = default(ushort);
            public ushort MoveToNextPoint = default(ushort);
            public ushort SuspendNextPositioning = default(ushort);
            public ushort StopAtTargetPosition = default(ushort);
            public ushort Homing = default(ushort);
            public ushort MoveToBasePosition = default(ushort);
            public ushort FastMoveToHome = default(ushort);
            public ushort Teaching = default(ushort);
            public ushort StartSpecialFunc = default(ushort);
            public ushort ReleaseSpecialFunc = default(ushort);
            public ushort ChgCtrlMode = default(ushort);
            public ushort StartSyncCtrl = default(ushort);
            public ushort ReleaseSyncCtrl = default(ushort);
            public ushort ChgCam = default(ushort);
            public ushort ReengageSyncTrqLimitClutch = default(ushort);
        }

        public class _MC_AXIS_CTRL
        {
            public ushort PointNo = default(ushort);
            public ushort CtrlMode = default(ushort);
            public double SetPosition = default(double);
            public double ChgPositioningTargetPos = default(double);
            public double ChgPositioningTargetVel = default(double);
            public double ChgVel = default(double);
            public ushort Override = default(ushort);
            public ushort SelectSpecialFunc = default(ushort);
            public double AbsPosFollowUpCtrlCmdVal = default(double);
            public double SyncTypeFollowUpCtrlCmdVal = default(double);
            public double VelCtrlCmdVel = default(double);
            public double VelCtrlTrqLimit = default(double);
            public double VelCtrlTrqFeedforward = default(double);
            public double TrqCtrlCmdTrq = default(double);
            public double TrqCtrlVelLimit = default(double);
            public double PosCtrlTrqLimit = default(double);
            public double PosCtrlVelFeedforward = default(double);
            public double PosCtrlTrqFeedforward = default(double);
            public ushort ChgSyncCamNo = default(ushort);
            public ushort ChgSyncCamPos = default(ushort);
            public ushort Controlword = default(ushort);
            public ushort TouchProbeFunction = default(ushort);
            public ushort[] Reserved = new ushort[30];
        }

        public class _MC_AXIS_GROUP_CFG
        {
            public ushort[] Axis = new ushort[16];
        }

        public class _MC_AXIS_GROUP_REF
        {
            public ushort AxisGroupNo = default(ushort);
        }

        public class _MC_AXIS_IO_STATUS
        {
            public bool PositiveLimit = default(bool);
            public bool NegativeLimit = default(bool);
            public bool HomeSensor = default(bool);
            public bool StopSensor = default(bool);
            public bool SyncCtrlExtInput = default(bool);
            public bool ServoEnd = default(bool);
            public bool ServoReady = default(bool);
            public bool DrvAlarm = default(bool);
            public bool ServoOn = default(bool);
            public bool Reserved = default(bool);
        }

        public class _MC_AXIS_MOTION_FUNC_MAP
        {
            public bool PosCtrlAvl = default(bool);
            public bool VelCtrlAvl = default(bool);
            public bool TrqCtrlAvl = default(bool);
            public bool FeedbackTrqAvl = default(bool);
            public bool StopSensorAvl = default(bool);
            public bool HomingBaseAvl = default(bool);
            public bool HomingDogNoZAvl = default(bool);
            public bool HomingDogPressAvl = default(bool);
            public bool HomingLimitSwAvl = default(bool);
            public bool HomingImmZAvl = default(bool);
            public bool PosCtrlTrqLimitAvl = default(bool);
            public bool PosCtrlVelFeedforwardAvl = default(bool);
            public bool PosCtrlTrqFeedforwardAvl = default(bool);
            public bool VelCtrlTrqLimitAvl = default(bool);
            public bool VelCtrlTrqFeedforwardAvl = default(bool);
            public bool TrqCtrlVelLimitAvl = default(bool);
            public bool DrvAlarmCodeAvl = default(bool);
            public bool[] Reserved = new bool[9];
        }

        public class _MC_AXIS_STATUS
        {
            public ushort ErrorCode = default(ushort);
            public ushort[] ErrorDetail = new ushort[5];
            public ushort WarningCode = default(ushort);
            public ushort[] WarningDetail = new ushort[5];
            public _MC_AXIS_IO_STATUS IOStatus = new _MC_AXIS_IO_STATUS();
            public ushort PosCtrlState = default(ushort);
            public double CmdPos = default(double);
            public double CmdVel = default(double);
            public int CmdPls = default(int);
            public double MechanicalPos = default(double);
            public ushort CurrentPointNo = default(ushort);
            public ushort MCode = default(ushort);
            public double TargetPos = default(double);
            public double InheritedVel = default(double);
            public ushort CurrentCtrlMode = default(ushort);
            public int FeedbackPls = default(int);
            public double ActPos = default(double);
            public double ActVel = default(double);
            public ushort DrvAlarmCode = default(ushort);
            public int EcatStatus = default(int);
            public ushort DrvAlarmDetail1 = default(ushort);
            public ushort DrvAlarmDetail2 = default(ushort);
            public ushort EcatNodeAdr = default(ushort);
            public ushort AxisIndex = default(ushort);
            public double TrqLimitMon = default(double);
            public double TrqFeedforwardMon = default(double);
            public double VelLimitMon = default(double);
            public double VelFeedforwardMon = default(double);
            public double FeedbackVel = default(double);
            public double FeedbackTrq = default(double);
            public int PosDeviation = default(int);
            public ushort CurrentSettlingTime = default(ushort);
            public ushort MaxSettlingTime = default(ushort);
            public _MC_AXIS_MOTION_FUNC_MAP MotionFuncMapSetting = new _MC_AXIS_MOTION_FUNC_MAP();
            public ushort StopSensorDetectionNum = default(ushort);
            public double StopSensorPos = default(double);
            public ushort[] Reserved = new ushort[12];
        }

        public class _MC_AXIS_STATUS_BIT
        {
            public bool PlsOutputDone = default(bool);
            public bool PositioningDone = default(bool);
            public bool MCodeStatus = default(bool);
            public bool AxisError = default(bool);
            public bool AxisWarning = default(bool);
            public bool InControl = default(bool);
            public bool ServoEnd = default(bool);
            public bool ServoReady = default(bool);
            public bool DrvAlarm = default(bool);
            public bool Jogging = default(bool);
            public bool HomeIsNotDefined = default(bool);
            public bool InSyncCtrl = default(bool);
            public bool MainClutchStatus = default(bool);
            public bool ChangingMainAxisPhaseCompensation = default(bool);
            public bool MainClutchEngaged = default(bool);
            public bool AuxClutchStatus = default(bool);
            public bool ChangingAuxAxisPhaseCompensation = default(bool);
            public bool AuxClutchEngaged = default(bool);
            public bool ChangingSyncVariableGear = default(bool);
            public bool TrqLimitClutchOff = default(bool);
            public bool DrvLimit = default(bool);
            public bool DrvWarning = default(bool);
            public bool[] Reserved = new bool[64];
        }

        public class _MC_AXIS_SYNC_STATUS
        {
            public double MainAxisPhaseCompensation = default(double);
            public double AuxAxisPhaseCompensation = default(double);
            public double StepAngleCompensation = default(double);
            public double MainAxisPhase = default(double);
            public double MainClutchInputAxisPhase = default(double);
            public double MainClutchInputAxisPos = default(double);
            public double MainClutchOutputAxisPhase = default(double);
            public double MainClutchOutputAxisPos = default(double);
            public double AuxClutchInputAxisPhase = default(double);
            public double AuxClutchInputAxisPos = default(double);
            public double AuxClutchOutputAxisPhase = default(double);
            public double AuxClutchOutputAxisPos = default(double);
            public double TrqLimitClutchInputAxisPhase = default(double);
            public double TrqLimitClutchInputAxisPos = default(double);
            public double TrqLimitClutchOutputAxisPhase = default(double);
            public double TrqLimitClutchOutputAxisPos = default(double);
            public double CamInputAxisPhase = default(double);
            public double CamOutputRelativePos = default(double);
            public ushort CurrentCamNo = default(ushort);
            public ushort ContactOutputCurrentParamNo = default(ushort);
            public ushort[] Reserved = new ushort[2];
        }

        public class _MC_CAM_SECTION
        {
            public uint Phase = default(uint);
            public ushort Curve = default(ushort);
            public double Displacement = default(double);
            public short StartVel = default(short);
            public short EndVel = default(short);
            public short StartAcc = default(short);
            public short EndAcc = default(short);
        }

        public class _MC_COMMON_CMP_CODE
        {
            public ushort FlashRomWrite = default(ushort);
            public ushort SyncContactParamChg = default(ushort);
            public ushort[] Reserved = new ushort[6];
        }

        public class _MC_COMMON_CTRL
        {
            public int[] ExtRefCmdVal = new int[48];
        }

        public class _MC_COMMON_PERFORMANCE
        {
            public uint CurrentCycleTime = default(uint);
            public uint MaxCycleTime = default(uint);
            public ushort CurrentLoadFactor = default(ushort);
            public ushort MaxLoadFactor = default(ushort);
            public ushort[] Reserved = new ushort[6];
        }

        public class _MC_COMMON_STATUS_BIT
        {
            public bool Enable = default(bool);
            public bool EnableError = default(bool);
            public bool UnitError = default(bool);
            public bool AxisError = default(bool);
            public bool AxisWarning = default(bool);
            public bool TestRunning = default(bool);
            public bool[] Reserved = new bool[48];
        }

        public class _MC_POINT_PARAM
        {
            public ushort PositioningMode = default(ushort);
            public ushort ContinuousMode = default(ushort);
            public ushort NextPointNo = default(ushort);
            public ushort MCodeNo = default(ushort);
            public double TargetPos = default(double);
            public ushort DwellTime = default(ushort);
            public ushort AxisGroupNo = default(ushort);
            public double StopSensorMovement_ArcPos = default(double);
            public double TargetVel = default(double);
            public double Acceleration = default(double);
            public double Deceleration = default(double);
            public double AuxArcRadius = default(double);
            public double TrqLimit = default(double);
            public ushort Revolution = default(ushort);
            public ushort[] Reserved = new ushort[3];
        }

        public class _MC_POINT_PARAM_AXIS
        {
            public _MC_POINT_PARAM[] Point = (_MC_POINT_PARAM[])CreateClassInstanceArray<_MC_POINT_PARAM>(new int[1] {50});
        }

        public class _MC_POS_CFG
        {
            public ushort CommonSetting1 = default(ushort);
            public ushort CommonSetting2 = default(ushort);
            public double OperationStartVel = default(double);
            public double OperationMaxVel = default(double);
            public double OperationAcc = default(double);
            public double OperationDec = default(double);
            public ushort OperationAccDecCurveRatio = default(ushort);
            public ushort OperationAccDecCurve = default(ushort);
            public double JogAcc = default(double);
            public double JogDec = default(double);
            public double JogStartVel = default(double);
            public double JogFastVel = default(double);
            public double JogInchingMovement = default(double);
            public ushort JogAccDecCurveRatio = default(ushort);
            public ushort JogAccDecCurve = default(ushort);
            public ushort HomingSetting = default(ushort);
            public ushort HomingAccDecCurveRatio = default(ushort);
            public double HomingStartVel = default(double);
            public double HomingCreepVel = default(double);
            public double HomingVel = default(double);
            public double HomingAcc = default(double);
            public double HomingDec = default(double);
            public double HomingPos = default(double);
            public double HomingBasePos = default(double);
            public double HomingMovementAfterDogOn = default(double);
            public ushort HomingMethod = default(ushort);
            public ushort HomingDwellTime = default(ushort);
            public ushort HomingPressTrqTime = default(ushort);
            public double HomingPressTrqThresh = default(double);
            public double AbsPosFollowUpCtrlVel = default(double);
            public double AbsPosFollowUpCtrlAcc = default(double);
            public double AbsPosFollowUpCtrlDec = default(double);
            public uint SyncTypeFollowUpCtrlGearNumerator = default(uint);
            public uint SyncTypeFollowUpCtrlGearDenominator = default(uint);
            public ushort SyncTypeFollowUpCtrlOutputFilter = default(ushort);
            public ushort[] Reserved = new ushort[95];
        }

        public class _MC_SYNC_CONTACT_OUTPUT
        {
            public bool[] Output = new bool[16];
        }

        public class _MC_SYNC_CONTACT_OUTPUT_SUB_CFG
        {
            public double OnVal = default(double);
            public double OffVal = default(double);
            public ushort OutputDst = default(ushort);
            public ushort[] Reserved = new ushort[3];
        }

        public class _MC_SYNC_EXT_INPUT_CFG
        {
            public ushort BaseSetting = default(ushort);
            public uint DevNo = default(uint);
            public int RingCounterMin = default(int);
            public int RingCounterMax = default(int);
        }

        public class _MC_SYNC_PARAM
        {
            public double InputAxisCycle = default(double);
            public ushort UnitAndPrecision = default(ushort);
            public ushort ClutchOffSlippingTimeAtDecStop = default(ushort);
            public ushort InputAxisPhaseInitMethod = default(ushort);
            public double MainAxisInitialPhase = default(double);
            public double MainAxisInitialPhaseAfterCompensation = default(double);
            public double MainClutchInputInitialPhase = default(double);
            public double AuxClutchInputInitialPhase = default(double);
            public ushort CamInClutchOutPhaseInitMethod = default(ushort);
            public double MainClutchOutputInitialPhase = default(double);
            public double AuxClutchOutputInitialPhase = default(double);
            public double TrqLimitClutchInputInitialPhase = default(double);
            public double CamInputInitialPhase = default(double);
            public double CamOutputBasePos = default(double);
            public ushort MainAxis1Input = default(ushort);
            public ushort MainAxis1CoordTrans = default(ushort);
            public uint MainAxis1CoordTransNumerator = default(uint);
            public uint MainAxis1CoordTransDenominator = default(uint);
            public ushort MainAxis2Input = default(ushort);
            public ushort MainAxis2CoordTrans = default(ushort);
            public uint MainAxis2CoordTransNumerator = default(uint);
            public uint MainAxis2CoordTransDenominator = default(uint);
            public ushort AuxAxisInput = default(ushort);
            public ushort AuxAxisCoordTrans = default(ushort);
            public uint AuxAxisCoordTransNumerator = default(uint);
            public uint AuxAxisCoordTransDenominator = default(uint);
            public double MainAxisPhaseCompensationCmdVal = default(double);
            public ushort MainAxisPhaseCompensationChgMethod = default(ushort);
            public ushort MainAxisPhaseCompensationChgTime = default(ushort);
            public double AuxAxisPhaseCompensationCmdVal = default(double);
            public ushort AuxAxisPhaseCompensationChgMethod = default(ushort);
            public ushort AuxAxisPhaseCompensationChgTime = default(ushort);
            public double StepAngleCompensationBaseVel = default(double);
            public double StepAngleCompensationBaseValue = default(double);
            public ushort StepAngleCompensationChgMethod = default(ushort);
            public ushort StepAngleCompensationChgTime = default(ushort);
            public int VariableGearRatioNumerator = default(int);
            public uint VariableGearRatioDenominator = default(uint);
            public ushort VariableGearRatioChgMethod = default(ushort);
            public ushort VariableGearRatioChgTime = default(ushort);
            public ushort MainClutchOnCondition = default(ushort);
            public ushort MainClutchOnEngagingMethod = default(ushort);
            public ushort MainClutchOnSlippingMode = default(ushort);
            public ushort MainClutchOnDisableMethod = default(ushort);
            public double MainClutchOnSettingVal = default(double);
            public double MainClutchOnDelay = default(double);
            public double MainClutchOnSlippage = default(double);
            public ushort MainClutchOnSlippingCurve = default(ushort);
            public ushort MainClutchOnSlippingTime = default(ushort);
            public ushort MainClutchOnFollowingTime = default(ushort);
            public double MainClutchOnFollowUpMovement = default(double);
            public ushort MainClutchOffCondition = default(ushort);
            public ushort MainClutchOffEngagingMethod = default(ushort);
            public ushort MainClutchOffSlippingMode = default(ushort);
            public ushort MainClutchOffDisableMethod = default(ushort);
            public double MainClutchOffSettingVal = default(double);
            public double MainClutchOffDelay = default(double);
            public double MainClutchOffSlippage = default(double);
            public ushort MainClutchOffSlippingCurve = default(ushort);
            public ushort MainClutchOffSlippingTime = default(ushort);
            public ushort AuxClutchOnCondition = default(ushort);
            public ushort AuxClutchOnEngagingMethod = default(ushort);
            public ushort AuxClutchOnSlippingMode = default(ushort);
            public ushort AuxClutchOnDisableMethod = default(ushort);
            public double AuxClutchOnSettingVal = default(double);
            public double AuxClutchOnDelay = default(double);
            public double AuxClutchOnSlippage = default(double);
            public ushort AuxClutchOnSlippingCurve = default(ushort);
            public ushort AuxClutchOnSlippingTime = default(ushort);
            public ushort AuxClutchOffCondition = default(ushort);
            public ushort AuxClutchOffEngagingMethod = default(ushort);
            public ushort AuxClutchOffSlippingMode = default(ushort);
            public ushort AuxClutchOffDisableMethod = default(ushort);
            public double AuxClutchOffSettingVal = default(double);
            public double AuxClutchOffDelay = default(double);
            public double AuxClutchOffSlippage = default(double);
            public ushort AuxClutchOffSlippingCurve = default(ushort);
            public ushort AuxClutchOffSlippingTime = default(ushort);
            public ushort CamDataNo = default(ushort);
            public ushort ContactOutputNo = default(ushort);
            public double CamStroke = default(double);
            public ushort SimMechanicalSyncStopMethod = default(ushort);
            public ushort TrqLimitClutchEngagingMethod = default(ushort);
            public ushort OutputFilterTimeConst = default(ushort);
            public double SimMechanicalSyncStopTrq = default(double);
            public double TrqLimitClutchOutputJogVel = default(double);
        }

        public class _OPERATION_RECORDER
        {
            public bool SaveRequest = default(bool);
            public bool InAction = default(bool);
            public bool SaveTriggerMonitor = default(bool);
            public bool SaveBusy = default(bool);
            public bool Collecting = default(bool);
            public bool SettingError = default(bool);
            public bool SaveComplete = default(bool);
            public bool SaveError = default(bool);
            public bool BufferShortage = default(bool);
            public bool BufferAllSaveMode = default(bool);
            public int AverageSamplingPeriod = default(int);
            public int AverageChangedDeviceNum = default(int);
            public int MaxCollectingPeriod = default(int);
            public ushort SaveFinCode = default(ushort);
            public ushort SaveCounter = default(ushort);
            public ushort SaveProgressInfo1 = default(ushort);
            public ushort SaveProgressInfo2 = default(ushort);
            public ushort SaveProgress = default(ushort);
            public byte[] SavePath = new byte[321];
            public ushort[] Reserved = new ushort[9];
        }

        public class _PROGRAM_INFO
        {
            public uint ScanTime = default(uint);
            public uint EndProcTime = default(uint);
            public uint MinScanTime = default(uint);
            public uint MaxScanTime = default(uint);
            public uint FixScanTimeSet = default(uint);
            public uint EndProcTimeSet = default(uint);
            public uint ExcessConstantScanTime = default(uint);
            public uint ExcessEndProcTime = default(uint);
            public ushort ProgramErrorDetail = default(ushort);
            public bool FixScanTimeEnable = default(bool);
            public bool FixTimeExcess = default(bool);
            public bool OCPDisabled = default(bool);
            public bool BackupBattError = default(bool);
            public bool ScanTimeMaxMinClear = default(bool);
            public bool FixEndProcTimeEnable = default(bool);
            public bool TimeError = default(bool);
            public bool ProjectPasswordAuthDisabled = default(bool);
            public ushort[] Reserved = new ushort[1];
        }

        public class _PROJECT_INFO
        {
            public byte[] ProjectName = new byte[65];
            public ushort SensorInstExecCount = default(ushort);
            public ushort PrjPasswordCertFailCount = default(ushort);
            public ushort PrjPasswordCertFailTotal = default(ushort);
            public ushort CpuFuncVersion = default(ushort);
            public ushort ProjectVersion = default(ushort);
        }

        public class _PROJECT_RECIPE_SAVE_LOAD
        {
            public bool Request = default(bool);
            public bool Busy = default(bool);
            public bool Complete = default(bool);
            public bool Error = default(bool);
            public ushort DriveNumber = default(ushort);
            public ushort FolderNumber = default(ushort);
            public ushort CompleteDriveNumber = default(ushort);
            public ushort CompleteFolderNumber = default(ushort);
            public ushort FinCode = default(ushort);
        }

        public class _RECIPE_SAVE
        {
            public bool Request = default(bool);
            public bool Busy = default(bool);
            public bool Complete = default(bool);
            public bool Error = default(bool);
            public ushort DriveNumber = default(ushort);
            public ushort InputFolderNumber = default(ushort);
            public ushort OutputFolderNumber = default(ushort);
            public ushort FinCode = default(ushort);
        }

        public class _SOCKET_STATUS
        {
            public ushort SocketStatus = default(ushort);
            public ushort TCPConnStatus = default(ushort);
            public ushort MyPortNo = default(ushort);
            public byte[] ConnAddress = new byte[16];
            public ushort ConnPortNo = default(ushort);
        }

        public class _STORAGE
        {
            public bool MemCardMountReq = default(bool);
            public bool MemCardUnmountReq = default(bool);
            public bool MemCardInUse = default(bool);
            public bool MemCardRecognized = default(bool);
            public bool MemCardExist = default(bool);
            public bool CpuMemoryMountReq = default(bool);
            public bool CpuMemoryUnmountReq = default(bool);
            public bool CpuMemoryInUse = default(bool);
            public bool CpuMemoryRecognized = default(bool);
            public _AUTOLOAD_CTRL AutoLoad = new _AUTOLOAD_CTRL();
            public _AUTOLOAD_CTRL RunLoad = new _AUTOLOAD_CTRL();
            public _PROJECT_RECIPE_SAVE_LOAD ProjectSave = new _PROJECT_RECIPE_SAVE_LOAD();
            public _PROJECT_RECIPE_SAVE_LOAD ProjectLoad = new _PROJECT_RECIPE_SAVE_LOAD();
            public _RECIPE_SAVE RecipeSave = new _RECIPE_SAVE();
            public _PROJECT_RECIPE_SAVE_LOAD RecipeLoad = new _PROJECT_RECIPE_SAVE_LOAD();
            public _CPU_MEMORY_SAVE CpuMemorySave = new _CPU_MEMORY_SAVE();
            public bool StorageFBIsRAMMode = default(bool);
            public bool ProjectBackupBusy = default(bool);
            public bool LoggingTraceBusy = default(bool);
            public bool LoggingInternalBufferOverflow = default(bool);
            public ushort PowerOffDuringStorageAccess = default(ushort);
            public ushort MemoryCardRetryCount = default(ushort);
            public ushort MemoryCardErrorCount = default(ushort);
            public ushort MemoryCardResetDelay = default(ushort);
            public uint UsageCpuMemory = default(uint);
        }

        public class _STRING_TO_VARIABLE_PARAM
        {
            public ushort Delimiter = default(ushort);
            public bool Hex = default(bool);
        }

        public class _UNIT_ID_ADR
        {
            public ushort UnitNo = default(ushort);
            public uint RelayAdr = default(uint);
            public uint DmAdr = default(uint);
        }

        public class _UNIT_SYNCHRONIZE
        {
            public uint RefreshStartTimeDelay = default(uint);
            public uint RefreshFinishTimeDelay = default(uint);
            public uint RefreshStartTimeMaxDelay = default(uint);
            public uint RefreshFinishTimeMaxDelay = default(uint);
            public uint RefreshExecutionTime = default(uint);
            public bool RefreshIntervalOver = default(bool);
            public ushort[] Reserved = new ushort[1];
        }

        public class _VARIABLE_TO_STRING_PARAM
        {
            public ushort Delimiter = default(ushort);
            public ushort CrLfCount = default(ushort);
            public ushort EndStr = default(ushort);
            public bool FixedDigit = default(bool);
            public bool Hex = default(bool);
        }

        public class _FILE_INFO
        {
            public byte[] FileName = new byte[129];
            public _FILE_STATUS FileStatus = new _FILE_STATUS();
        }

        public class _MC_AXIS_REF
        {
            public ushort AxisNo = default(ushort);
            public _MC_AXIS_STATUS Status = new _MC_AXIS_STATUS();
            public _MC_AXIS_CMP_CODE CmpCode = new _MC_AXIS_CMP_CODE();
            public _MC_AXIS_SYNC_STATUS SyncStatus = new _MC_AXIS_SYNC_STATUS();
            public _MC_AXIS_STATUS_BIT StatusBit = new _MC_AXIS_STATUS_BIT();
        }

        public class _MC_COMMON_CFG
        {
            public ushort UnitCfg = default(ushort);
            public _MC_SYNC_EXT_INPUT_CFG[] SyncExtInputCfg = (_MC_SYNC_EXT_INPUT_CFG[])CreateClassInstanceArray<_MC_SYNC_EXT_INPUT_CFG>(new int[1] {48});
        }

        public class _MC_COMMON_STATUS
        {
            public ushort UnitErrorCode = default(ushort);
            public ushort[] UnitErrorDetail = new ushort[5];
            public _MC_SYNC_CONTACT_OUTPUT[] SyncContactOutput = (_MC_SYNC_CONTACT_OUTPUT[])CreateClassInstanceArray<_MC_SYNC_CONTACT_OUTPUT>(new int[1] {32});
            public ushort[] Reserved = new ushort[2];
        }

        public class _MC_SYNC_CONTACT_OUTPUT_CFG
        {
            public _MC_SYNC_CONTACT_OUTPUT_SUB_CFG[] ConfigNo = (_MC_SYNC_CONTACT_OUTPUT_SUB_CFG[])CreateClassInstanceArray<_MC_SYNC_CONTACT_OUTPUT_SUB_CFG>(new int[1] {32});
        }

        public class _MC_COMMON
        {
            public _MC_COMMON_STATUS Status = new _MC_COMMON_STATUS();
            public _MC_COMMON_CMP_CODE CmpCode = new _MC_COMMON_CMP_CODE();
            public _MC_COMMON_PERFORMANCE Performance = new _MC_COMMON_PERFORMANCE();
            public _MC_COMMON_STATUS_BIT StatusBit = new _MC_COMMON_STATUS_BIT();
        }

        public static int[] NewIndices(Array target)
        {
            int rank = target.Rank;
            int[] indices = new int[rank];
            Array.Clear(indices, 0, rank);
            indices[ rank - 1 ]--;
            return indices;
        }

        public static void NextIndices(Array target, int[] indices)
        {
            int rank = target.Rank;
            indices[ rank - 1 ]++;
            for ( int dim = rank - 1; dim >= 0; dim-- )
            {
                if ( indices[ dim ] > target.GetUpperBound(dim) )
                {
                    if ( dim == 0 ) break;
                    for ( int j = dim; j < rank; j++ ) indices[ j ] = target.GetLowerBound(j);
                    indices[ dim - 1 ]++;
                }
            }
        }

        public static Array CreateClassInstanceArray<T>(int[] sizes)
        {
            Array entity = Array.CreateInstance(typeof(T), sizes);
            int[] indices = NewIndices(entity);
            for ( int i = 0; i < entity.Length; i++ )
            {
                NextIndices(entity, indices);
                entity.SetValue(Activator.CreateInstance(typeof(T)), indices);
            }
            return entity;
        }

        private static void SwapBytes(byte[] tgt, int byteSize, int byteOffset = 0)
        {
            byte tmpByte;
            for ( int i = 0; i < byteSize / 2; i++ )
            {
                tmpByte = tgt[ i * 2 + byteOffset ];
                tgt[ i * 2 + byteOffset ] = tgt[ i * 2 + 1 + byteOffset ];
                tgt[ i * 2 + 1 + byteOffset ] = tmpByte;
            }
        }

        public static void ByteToBoolBase(Array dst, byte[] src, int len = 1, int wordOffset = 0, int bitOffset = 0)
        {
            int byteOffset = (wordOffset * 2) + (bitOffset / 8);
            int byteBitOffset = bitOffset % 8;
            int[] indices = NewIndices(src);
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                dst.SetValue(( src[ ( ( i + byteBitOffset ) / 8 ) + byteOffset ] & ( 1 << ( i + byteBitOffset ) % 8 ) ) != 0, indices);
            }
        }

        public static void ByteToBool(ref bool dst, byte[] src, int len = 1, int wordOffset = 0, int bitOffset = 0)
        {
            int byteOffset = (wordOffset * 2) + (bitOffset / 8);
            int byteBitOffset = bitOffset % 8;
            dst = ( src[ byteOffset ] & 1 << byteBitOffset ) != 0;
        }

        public static void ByteToBool(ref bool[] dst, byte[] src, int len = 1, int wordOffset = 0, int bitOffset = 0)
        {
            ByteToBoolBase(dst, src, len, wordOffset, bitOffset);
        }
        public static void ByteToBool(ref bool[,] dst, byte[] src, int len = 1, int wordOffset = 0, int bitOffset = 0)
        {
            ByteToBoolBase(dst, src, len, wordOffset, bitOffset);
        }
        public static void ByteToBool(ref bool[,,] dst, byte[] src, int len = 1, int wordOffset = 0, int bitOffset = 0)
        {
            ByteToBoolBase(dst, src, len, wordOffset, bitOffset);
        }
        public static void ByteToBool(ref bool[,,,] dst, byte[] src, int len = 1, int wordOffset = 0, int bitOffset = 0)
        {
            ByteToBoolBase(dst, src, len, wordOffset, bitOffset);
        }
        public static void ByteToBool(ref bool[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0, int bitOffset = 0)
        {
            ByteToBoolBase(dst, src, len, wordOffset, bitOffset);
        }
        public static void ByteToBool(ref bool[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0, int bitOffset = 0)
        {
            ByteToBoolBase(dst, src, len, wordOffset, bitOffset);
        }
        public static void ByteToBool(ref bool[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0, int bitOffset = 0)
        {
            ByteToBoolBase(dst, src, len, wordOffset, bitOffset);
        }
        public static void ByteToBool(ref bool[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0, int bitOffset = 0)
        {
            ByteToBoolBase(dst, src, len, wordOffset, bitOffset);
        }

        public static void ByteToShort(ref short dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            dst = BitConverter.ToInt16(src, wordOffset * 2);
        }

        public static void ByteToShort(ref short[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(short));
        }
        public static void ByteToShort(ref short[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(short));
        }
        public static void ByteToShort(ref short[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(short));
        }
        public static void ByteToShort(ref short[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(short));
        }
        public static void ByteToShort(ref short[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(short));
        }
        public static void ByteToShort(ref short[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(short));
        }
        public static void ByteToShort(ref short[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(short));
        }
        public static void ByteToShort(ref short[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(short));
        }

        public static void ByteToUshort(ref ushort dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            dst = BitConverter.ToUInt16(src, wordOffset * 2);
        }

        public static void ByteToUshort(ref ushort[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(ushort));
        }
        public static void ByteToUshort(ref ushort[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(ushort));
        }
        public static void ByteToUshort(ref ushort[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(ushort));
        }
        public static void ByteToUshort(ref ushort[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(ushort));
        }
        public static void ByteToUshort(ref ushort[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(ushort));
        }
        public static void ByteToUshort(ref ushort[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(ushort));
        }
        public static void ByteToUshort(ref ushort[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(ushort));
        }
        public static void ByteToUshort(ref ushort[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(ushort));
        }

        public static void ByteToInt(ref int dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            dst = BitConverter.ToInt32(src, wordOffset * 2);
        }

        public static void ByteToInt(ref int[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(int));
        }
        public static void ByteToInt(ref int[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(int));
        }
        public static void ByteToInt(ref int[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(int));
        }
        public static void ByteToInt(ref int[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(int));
        }
        public static void ByteToInt(ref int[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(int));
        }
        public static void ByteToInt(ref int[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(int));
        }
        public static void ByteToInt(ref int[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(int));
        }
        public static void ByteToInt(ref int[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(int));
        }

        public static void ByteToUint(ref uint dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            dst = BitConverter.ToUInt32(src, wordOffset * 2);
        }

        public static void ByteToUint(ref uint[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(uint));
        }
        public static void ByteToUint(ref uint[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(uint));
        }
        public static void ByteToUint(ref uint[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(uint));
        }
        public static void ByteToUint(ref uint[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(uint));
        }
        public static void ByteToUint(ref uint[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(uint));
        }
        public static void ByteToUint(ref uint[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(uint));
        }
        public static void ByteToUint(ref uint[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(uint));
        }
        public static void ByteToUint(ref uint[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(uint));
        }

        public static void ByteToFloat(ref float dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            dst = BitConverter.ToSingle(src, wordOffset * 2);
        }

        public static void ByteToFloat(ref float[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(float));
        }
        public static void ByteToFloat(ref float[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(float));
        }
        public static void ByteToFloat(ref float[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(float));
        }
        public static void ByteToFloat(ref float[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(float));
        }
        public static void ByteToFloat(ref float[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(float));
        }
        public static void ByteToFloat(ref float[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(float));
        }
        public static void ByteToFloat(ref float[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(float));
        }
        public static void ByteToFloat(ref float[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(float));
        }

        public static void ByteToDouble(ref double dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            dst = BitConverter.ToDouble(src, wordOffset * 2);
        }

        public static void ByteToDouble(ref double[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(double));
        }
        public static void ByteToDouble(ref double[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(double));
        }
        public static void ByteToDouble(ref double[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(double));
        }
        public static void ByteToDouble(ref double[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(double));
        }
        public static void ByteToDouble(ref double[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(double));
        }
        public static void ByteToDouble(ref double[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(double));
        }
        public static void ByteToDouble(ref double[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(double));
        }
        public static void ByteToDouble(ref double[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, wordOffset * 2, dst, 0, len * sizeof(double));
        }

        public static void ByteToString(ref byte[] dst, byte[] src, int len = 1, int wordOffset = 0, int stringSize = 0)
        {
            byte[] strTmp = new byte[len * stringSize];
            Array.Copy(src, wordOffset * 2, strTmp, 0, len * stringSize);
            SwapBytes(strTmp, len * stringSize);
            Buffer.BlockCopy(strTmp, 0, dst, 0, len * stringSize);
        }
        public static void ByteToString(ref byte[,] dst, byte[] src, int len = 1, int wordOffset = 0, int stringSize = 0)
        {
            byte[] strTmp = new byte[len * stringSize];
            Array.Copy(src, wordOffset * 2, strTmp, 0, len * stringSize);
            SwapBytes(strTmp, len * stringSize);
            Buffer.BlockCopy(strTmp, 0, dst, 0, len * stringSize);
        }
        public static void ByteToString(ref byte[,,] dst, byte[] src, int len = 1, int wordOffset = 0, int stringSize = 0)
        {
            byte[] strTmp = new byte[len * stringSize];
            Array.Copy(src, wordOffset * 2, strTmp, 0, len * stringSize);
            SwapBytes(strTmp, len * stringSize);
            Buffer.BlockCopy(strTmp, 0, dst, 0, len * stringSize);
        }
        public static void ByteToString(ref byte[,,,] dst, byte[] src, int len = 1, int wordOffset = 0, int stringSize = 0)
        {
            byte[] strTmp = new byte[len * stringSize];
            Array.Copy(src, wordOffset * 2, strTmp, 0, len * stringSize);
            SwapBytes(strTmp, len * stringSize);
            Buffer.BlockCopy(strTmp, 0, dst, 0, len * stringSize);
        }
        public static void ByteToString(ref byte[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0, int stringSize = 0)
        {
            byte[] strTmp = new byte[len * stringSize];
            Array.Copy(src, wordOffset * 2, strTmp, 0, len * stringSize);
            SwapBytes(strTmp, len * stringSize);
            Buffer.BlockCopy(strTmp, 0, dst, 0, len * stringSize);
        }
        public static void ByteToString(ref byte[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0, int stringSize = 0)
        {
            byte[] strTmp = new byte[len * stringSize];
            Array.Copy(src, wordOffset * 2, strTmp, 0, len * stringSize);
            SwapBytes(strTmp, len * stringSize);
            Buffer.BlockCopy(strTmp, 0, dst, 0, len * stringSize);
        }
        public static void ByteToString(ref byte[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0, int stringSize = 0)
        {
            byte[] strTmp = new byte[len * stringSize];
            Array.Copy(src, wordOffset * 2, strTmp, 0, len * stringSize);
            SwapBytes(strTmp, len * stringSize);
            Buffer.BlockCopy(strTmp, 0, dst, 0, len * stringSize);
        }
        public static void ByteToString(ref byte[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0, int stringSize = 0)
        {
            byte[] strTmp = new byte[len * stringSize];
            Array.Copy(src, wordOffset * 2, strTmp, 0, len * stringSize);
            SwapBytes(strTmp, len * stringSize);
            Buffer.BlockCopy(strTmp, 0, dst, 0, len * stringSize);
        }

        public static void BoolToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0, int bitOffset = 0)
        {
            int[] indices = NewIndices(dst);
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(dst, indices);
                BoolToByte(ref dst, ( bool ) src.GetValue(indices), 1, wordOffset, bitOffset);
                bitOffset++;
                if ( bitOffset >= 16 )
                {
                    bitOffset = 0;
                    wordOffset++;
                }
            }
        }

        public static void BoolToByte(ref byte[] dst, bool src, int len = 1, int wordOffset = 0, int bitOffset = 0)
        {
            int byteOffset = (wordOffset * 2) + (bitOffset / 8);
            int byteBitOffset = bitOffset % 8;
            if ( src )
            {
                dst[ byteOffset ] |= ( byte ) ( 1 << byteBitOffset );
            }
            else
            {
                dst[ byteOffset ] &= ( byte ) ~( 1 << byteBitOffset );
            }
        }

        public static void BoolToByte(ref byte[] dst, bool[] src, int len = 1, int wordOffset = 0, int bitOffset = 0)
        {
            BoolToByteBase(ref dst, src, len, wordOffset, bitOffset);
        }
        public static void BoolToByte(ref byte[] dst, bool[,] src, int len = 1, int wordOffset = 0, int bitOffset = 0)
        {
            BoolToByteBase(ref dst, src, len, wordOffset, bitOffset);
        }
        public static void BoolToByte(ref byte[] dst, bool[,,] src, int len = 1, int wordOffset = 0, int bitOffset = 0)
        {
            BoolToByteBase(ref dst, src, len, wordOffset, bitOffset);
        }
        public static void BoolToByte(ref byte[] dst, bool[,,,] src, int len = 1, int wordOffset = 0, int bitOffset = 0)
        {
            BoolToByteBase(ref dst, src, len, wordOffset, bitOffset);
        }
        public static void BoolToByte(ref byte[] dst, bool[,,,,] src, int len = 1, int wordOffset = 0, int bitOffset = 0)
        {
            BoolToByteBase(ref dst, src, len, wordOffset, bitOffset);
        }
        public static void BoolToByte(ref byte[] dst, bool[,,,,,] src, int len = 1, int wordOffset = 0, int bitOffset = 0)
        {
            BoolToByteBase(ref dst, src, len, wordOffset, bitOffset);
        }
        public static void BoolToByte(ref byte[] dst, bool[,,,,,,] src, int len = 1, int wordOffset = 0, int bitOffset = 0)
        {
            BoolToByteBase(ref dst, src, len, wordOffset, bitOffset);
        }
        public static void BoolToByte(ref byte[] dst, bool[,,,,,,,] src, int len = 1, int wordOffset = 0, int bitOffset = 0)
        {
            BoolToByteBase(ref dst, src, len, wordOffset, bitOffset);
        }

        public static void ShortToByte(ref byte[] dst, short src, int len = 1, int wordOffset = 0)
        {
            Array.Copy(BitConverter.GetBytes(src), 0, dst, wordOffset * 2, len * sizeof(short));
        }

        public static void ShortToByte(ref byte[] dst, short[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(short));
        }
        public static void ShortToByte(ref byte[] dst, short[,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(short));
        }
        public static void ShortToByte(ref byte[] dst, short[,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(short));
        }
        public static void ShortToByte(ref byte[] dst, short[,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(short));
        }
        public static void ShortToByte(ref byte[] dst, short[,,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(short));
        }
        public static void ShortToByte(ref byte[] dst, short[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(short));
        }
        public static void ShortToByte(ref byte[] dst, short[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(short));
        }
        public static void ShortToByte(ref byte[] dst, short[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(short));
        }

        public static void UshortToByte(ref byte[] dst, ushort src, int len = 1, int wordOffset = 0)
        {
            Array.Copy(BitConverter.GetBytes(src), 0, dst, wordOffset * 2, len * sizeof(ushort));
        }

        public static void UshortToByte(ref byte[] dst, ushort[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(ushort));
        }
        public static void UshortToByte(ref byte[] dst, ushort[,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(ushort));
        }
        public static void UshortToByte(ref byte[] dst, ushort[,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(ushort));
        }
        public static void UshortToByte(ref byte[] dst, ushort[,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(ushort));
        }
        public static void UshortToByte(ref byte[] dst, ushort[,,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(ushort));
        }
        public static void UshortToByte(ref byte[] dst, ushort[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(ushort));
        }
        public static void UshortToByte(ref byte[] dst, ushort[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(ushort));
        }
        public static void UshortToByte(ref byte[] dst, ushort[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(ushort));
        }

        public static void IntToByte(ref byte[] dst, int src, int len = 1, int wordOffset = 0)
        {
            Array.Copy(BitConverter.GetBytes(src), 0, dst, wordOffset * 2, len * sizeof(int));
        }

        public static void IntToByte(ref byte[] dst, int[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(int));
        }
        public static void IntToByte(ref byte[] dst, int[,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(int));
        }
        public static void IntToByte(ref byte[] dst, int[,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(int));
        }
        public static void IntToByte(ref byte[] dst, int[,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(int));
        }
        public static void IntToByte(ref byte[] dst, int[,,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(int));
        }
        public static void IntToByte(ref byte[] dst, int[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(int));
        }
        public static void IntToByte(ref byte[] dst, int[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(int));
        }
        public static void IntToByte(ref byte[] dst, int[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(int));
        }

        public static void UintToByte(ref byte[] dst, uint src, int len = 1, int wordOffset = 0)
        {
            Array.Copy(BitConverter.GetBytes(src), 0, dst, wordOffset * 2, len * sizeof(uint));
        }

        public static void UintToByte(ref byte[] dst, uint[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(uint));
        }
        public static void UintToByte(ref byte[] dst, uint[,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(uint));
        }
        public static void UintToByte(ref byte[] dst, uint[,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(uint));
        }
        public static void UintToByte(ref byte[] dst, uint[,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(uint));
        }
        public static void UintToByte(ref byte[] dst, uint[,,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(uint));
        }
        public static void UintToByte(ref byte[] dst, uint[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(uint));
        }
        public static void UintToByte(ref byte[] dst, uint[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(uint));
        }
        public static void UintToByte(ref byte[] dst, uint[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(uint));
        }

        public static void FloatToByte(ref byte[] dst, float src, int len = 1, int wordOffset = 0)
        {
            Array.Copy(BitConverter.GetBytes(src), 0, dst, wordOffset * 2, len * sizeof(float));
        }

        public static void FloatToByte(ref byte[] dst, float[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(float));
        }
        public static void FloatToByte(ref byte[] dst, float[,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(float));
        }
        public static void FloatToByte(ref byte[] dst, float[,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(float));
        }
        public static void FloatToByte(ref byte[] dst, float[,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(float));
        }
        public static void FloatToByte(ref byte[] dst, float[,,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(float));
        }
        public static void FloatToByte(ref byte[] dst, float[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(float));
        }
        public static void FloatToByte(ref byte[] dst, float[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(float));
        }
        public static void FloatToByte(ref byte[] dst, float[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(float));
        }

        public static void DoubleToByte(ref byte[] dst, double src, int len = 1, int wordOffset = 0)
        {
            Array.Copy(BitConverter.GetBytes(src), 0, dst, wordOffset * 2, len * sizeof(double));
        }

        public static void DoubleToByte(ref byte[] dst, double[] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(double));
        }
        public static void DoubleToByte(ref byte[] dst, double[,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(double));
        }
        public static void DoubleToByte(ref byte[] dst, double[,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(double));
        }
        public static void DoubleToByte(ref byte[] dst, double[,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(double));
        }
        public static void DoubleToByte(ref byte[] dst, double[,,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(double));
        }
        public static void DoubleToByte(ref byte[] dst, double[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(double));
        }
        public static void DoubleToByte(ref byte[] dst, double[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(double));
        }
        public static void DoubleToByte(ref byte[] dst, double[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * sizeof(double));
        }

        public static void StringToByte(ref byte[] dst, byte[] src, int len = 1, int wordOffset = 0, int stringSize = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * stringSize);
            SwapBytes(dst, len * stringSize, wordOffset * 2);
        }
        public static void StringToByte(ref byte[] dst, byte[,] src, int len = 1, int wordOffset = 0, int stringSize = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * stringSize);
            SwapBytes(dst, len * stringSize, wordOffset * 2);
        }
        public static void StringToByte(ref byte[] dst, byte[,,] src, int len = 1, int wordOffset = 0, int stringSize = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * stringSize);
            SwapBytes(dst, len * stringSize, wordOffset * 2);
        }
        public static void StringToByte(ref byte[] dst, byte[,,,] src, int len = 1, int wordOffset = 0, int stringSize = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * stringSize);
            SwapBytes(dst, len * stringSize, wordOffset * 2);
        }
        public static void StringToByte(ref byte[] dst, byte[,,,,] src, int len = 1, int wordOffset = 0, int stringSize = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * stringSize);
            SwapBytes(dst, len * stringSize, wordOffset * 2);
        }
        public static void StringToByte(ref byte[] dst, byte[,,,,,] src, int len = 1, int wordOffset = 0, int stringSize = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * stringSize);
            SwapBytes(dst, len * stringSize, wordOffset * 2);
        }
        public static void StringToByte(ref byte[] dst, byte[,,,,,,] src, int len = 1, int wordOffset = 0, int stringSize = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * stringSize);
            SwapBytes(dst, len * stringSize, wordOffset * 2);
        }
        public static void StringToByte(ref byte[] dst, byte[,,,,,,,] src, int len = 1, int wordOffset = 0, int stringSize = 0)
        {
            Buffer.BlockCopy(src, 0, dst, wordOffset * 2, len * stringSize);
            SwapBytes(dst, len * stringSize, wordOffset * 2);
        }

        public static void ByteTo_stMemArr(ref stMemArr dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUshort(ref dst.auSample, src, 100, 0 + wordOffset);
            ByteToString(ref dst.astrSample, src, 10, 100 + wordOffset, 10);
        }
        private static void ByteToBase_stMemArr(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                stMemArr elemTmp = new stMemArr();
                NextIndices(dst, indices);
                ByteTo_stMemArr(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += stMemArr_WSIZE;
            }
        }
        public static void ByteTo_stMemArr(ref stMemArr[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase_stMemArr(dst, src, len, wordOffset);
        }
        public static void ByteTo_stMemArr(ref stMemArr[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase_stMemArr(dst, src, len, wordOffset);
        }
        public static void ByteTo_stMemArr(ref stMemArr[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase_stMemArr(dst, src, len, wordOffset);
        }
        public static void ByteTo_stMemArr(ref stMemArr[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase_stMemArr(dst, src, len, wordOffset);
        }
        public static void ByteTo_stMemArr(ref stMemArr[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase_stMemArr(dst, src, len, wordOffset);
        }
        public static void ByteTo_stMemArr(ref stMemArr[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase_stMemArr(dst, src, len, wordOffset);
        }
        public static void ByteTo_stMemArr(ref stMemArr[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase_stMemArr(dst, src, len, wordOffset);
        }
        public static void ByteTo_stMemArr(ref stMemArr[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase_stMemArr(dst, src, len, wordOffset);
        }

        public static void ByteTo_stNode(ref stNode dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBool(ref dst.xMember, src, 1, 0 + wordOffset, 0);
            ByteToBool(ref dst.xMember2, src, 1, 0 + wordOffset, 1);
            ByteToUshort(ref dst.uMember, src, 1, 1 + wordOffset);
            ByteToShort(ref dst.iMember, src, 1, 2 + wordOffset);
            ByteToUint(ref dst.duMember, src, 1, 4 + wordOffset);
            ByteToInt(ref dst.diMember, src, 1, 6 + wordOffset);
            ByteToFloat(ref dst.fMember, src, 1, 8 + wordOffset);
            ByteToDouble(ref dst.dfMember, src, 1, 10 + wordOffset);
            ByteToString(ref dst.strMember, src, 1, 14 + wordOffset, 16);
        }
        private static void ByteToBase_stNode(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                stNode elemTmp = new stNode();
                NextIndices(dst, indices);
                ByteTo_stNode(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += stNode_WSIZE;
            }
        }
        public static void ByteTo_stNode(ref stNode[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase_stNode(dst, src, len, wordOffset);
        }
        public static void ByteTo_stNode(ref stNode[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase_stNode(dst, src, len, wordOffset);
        }
        public static void ByteTo_stNode(ref stNode[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase_stNode(dst, src, len, wordOffset);
        }
        public static void ByteTo_stNode(ref stNode[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase_stNode(dst, src, len, wordOffset);
        }
        public static void ByteTo_stNode(ref stNode[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase_stNode(dst, src, len, wordOffset);
        }
        public static void ByteTo_stNode(ref stNode[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase_stNode(dst, src, len, wordOffset);
        }
        public static void ByteTo_stNode(ref stNode[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase_stNode(dst, src, len, wordOffset);
        }
        public static void ByteTo_stNode(ref stNode[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase_stNode(dst, src, len, wordOffset);
        }

        public static void ByteTo_stParent(ref stParent dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBool(ref dst.xReq, src, 1, 0 + wordOffset, 0);
            ByteToBool(ref dst.xCmp, src, 1, 0 + wordOffset, 1);
            ByteToBool(ref dst.xErr, src, 1, 0 + wordOffset, 2);
            ByteToUshort(ref dst.uErrCode, src, 1, 1 + wordOffset);
            ByteTo_stNode(ref dst.stNode_Member, src, 1, 2 + wordOffset);
            ByteTo_stNode(ref dst.astNode, src, 10, 24 + wordOffset);
        }
        private static void ByteToBase_stParent(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                stParent elemTmp = new stParent();
                NextIndices(dst, indices);
                ByteTo_stParent(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += stParent_WSIZE;
            }
        }
        public static void ByteTo_stParent(ref stParent[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase_stParent(dst, src, len, wordOffset);
        }
        public static void ByteTo_stParent(ref stParent[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase_stParent(dst, src, len, wordOffset);
        }
        public static void ByteTo_stParent(ref stParent[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase_stParent(dst, src, len, wordOffset);
        }
        public static void ByteTo_stParent(ref stParent[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase_stParent(dst, src, len, wordOffset);
        }
        public static void ByteTo_stParent(ref stParent[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase_stParent(dst, src, len, wordOffset);
        }
        public static void ByteTo_stParent(ref stParent[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase_stParent(dst, src, len, wordOffset);
        }
        public static void ByteTo_stParent(ref stParent[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase_stParent(dst, src, len, wordOffset);
        }
        public static void ByteTo_stParent(ref stParent[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase_stParent(dst, src, len, wordOffset);
        }

        public static void ByteTo__ACCESS_WINDOW(ref _ACCESS_WINDOW dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBool(ref dst.UpKeyPressed, src, 1, 0 + wordOffset, 0);
            ByteToBool(ref dst.DownKeyPressed, src, 1, 0 + wordOffset, 1);
            ByteToBool(ref dst.LeftKeyPressed, src, 1, 0 + wordOffset, 2);
            ByteToBool(ref dst.RightKeyPressed, src, 1, 0 + wordOffset, 3);
            ByteToBool(ref dst.MenuKeyPressed, src, 1, 0 + wordOffset, 4);
            ByteToBool(ref dst.EnterKeyPressed, src, 1, 0 + wordOffset, 5);
            ByteToBool(ref dst.UserMessageDisplayed, src, 1, 0 + wordOffset, 15);
            ByteToBool(ref dst.BlinkLine, src, 4, 1 + wordOffset, 0);
            ByteToBool(ref dst.DisplayUserMessage, src, 63, 2 + wordOffset, 1);
            ByteToUshort(ref dst.UserMessageDisplayID, src, 1, 10 + wordOffset);
            ByteToUshort(ref dst.InitialDispLangSetting, src, 1, 11 + wordOffset);
            ByteToUshort(ref dst.InitialCommentNumberSetting, src, 1, 12 + wordOffset);
            ByteToUshort(ref dst.WindowOperationDisable, src, 1, 13 + wordOffset);
            ByteToUshort(ref dst.InitScreenSetValid, src, 1, 14 + wordOffset);
            ByteToUshort(ref dst.InitScreenSetDeviceType, src, 1, 15 + wordOffset);
            ByteToUint(ref dst.InitScreenSetScreenID, src, 1, 16 + wordOffset);
            ByteToUint(ref dst.InitScreenSetDeviceNumber, src, 1, 18 + wordOffset);
            ByteToUshort(ref dst.InitScreenSetDisplayFormat, src, 1, 20 + wordOffset);
            ByteToUshort(ref dst.InitScreenSetDeviceDisplay, src, 1, 21 + wordOffset);
            ByteToUshort(ref dst.InitScreenSetKeyLockStatus, src, 1, 22 + wordOffset);
            ByteToUshort(ref dst.Reserved, src, 1, 23 + wordOffset);
        }
        private static void ByteToBase__ACCESS_WINDOW(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _ACCESS_WINDOW elemTmp = new _ACCESS_WINDOW();
                NextIndices(dst, indices);
                ByteTo__ACCESS_WINDOW(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _ACCESS_WINDOW_WSIZE;
            }
        }
        public static void ByteTo__ACCESS_WINDOW(ref _ACCESS_WINDOW[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__ACCESS_WINDOW(dst, src, len, wordOffset);
        }
        public static void ByteTo__ACCESS_WINDOW(ref _ACCESS_WINDOW[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__ACCESS_WINDOW(dst, src, len, wordOffset);
        }
        public static void ByteTo__ACCESS_WINDOW(ref _ACCESS_WINDOW[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__ACCESS_WINDOW(dst, src, len, wordOffset);
        }
        public static void ByteTo__ACCESS_WINDOW(ref _ACCESS_WINDOW[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__ACCESS_WINDOW(dst, src, len, wordOffset);
        }
        public static void ByteTo__ACCESS_WINDOW(ref _ACCESS_WINDOW[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__ACCESS_WINDOW(dst, src, len, wordOffset);
        }
        public static void ByteTo__ACCESS_WINDOW(ref _ACCESS_WINDOW[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__ACCESS_WINDOW(dst, src, len, wordOffset);
        }
        public static void ByteTo__ACCESS_WINDOW(ref _ACCESS_WINDOW[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__ACCESS_WINDOW(dst, src, len, wordOffset);
        }
        public static void ByteTo__ACCESS_WINDOW(ref _ACCESS_WINDOW[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__ACCESS_WINDOW(dst, src, len, wordOffset);
        }

        public static void ByteTo__AUTOLOAD_CTRL(ref _AUTOLOAD_CTRL dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUshort(ref dst.FolderNumber, src, 1, 1 + wordOffset);
            ByteToUshort(ref dst.CompleteFolderNumber, src, 1, 3 + wordOffset);
            ByteToUshort(ref dst.FinCode, src, 1, 4 + wordOffset);
        }
        private static void ByteToBase__AUTOLOAD_CTRL(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _AUTOLOAD_CTRL elemTmp = new _AUTOLOAD_CTRL();
                NextIndices(dst, indices);
                ByteTo__AUTOLOAD_CTRL(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _AUTOLOAD_CTRL_WSIZE;
            }
        }
        public static void ByteTo__AUTOLOAD_CTRL(ref _AUTOLOAD_CTRL[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__AUTOLOAD_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__AUTOLOAD_CTRL(ref _AUTOLOAD_CTRL[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__AUTOLOAD_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__AUTOLOAD_CTRL(ref _AUTOLOAD_CTRL[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__AUTOLOAD_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__AUTOLOAD_CTRL(ref _AUTOLOAD_CTRL[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__AUTOLOAD_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__AUTOLOAD_CTRL(ref _AUTOLOAD_CTRL[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__AUTOLOAD_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__AUTOLOAD_CTRL(ref _AUTOLOAD_CTRL[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__AUTOLOAD_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__AUTOLOAD_CTRL(ref _AUTOLOAD_CTRL[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__AUTOLOAD_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__AUTOLOAD_CTRL(ref _AUTOLOAD_CTRL[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__AUTOLOAD_CTRL(dst, src, len, wordOffset);
        }

        public static void ByteTo__CPU_MEMORY_SAVE(ref _CPU_MEMORY_SAVE dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBool(ref dst.Request, src, 1, 0 + wordOffset, 0);
            ByteToBool(ref dst.Busy, src, 1, 0 + wordOffset, 1);
            ByteToBool(ref dst.Complete, src, 1, 0 + wordOffset, 2);
            ByteToBool(ref dst.Error, src, 1, 0 + wordOffset, 3);
        }
        private static void ByteToBase__CPU_MEMORY_SAVE(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _CPU_MEMORY_SAVE elemTmp = new _CPU_MEMORY_SAVE();
                NextIndices(dst, indices);
                ByteTo__CPU_MEMORY_SAVE(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _CPU_MEMORY_SAVE_WSIZE;
            }
        }
        public static void ByteTo__CPU_MEMORY_SAVE(ref _CPU_MEMORY_SAVE[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__CPU_MEMORY_SAVE(dst, src, len, wordOffset);
        }
        public static void ByteTo__CPU_MEMORY_SAVE(ref _CPU_MEMORY_SAVE[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__CPU_MEMORY_SAVE(dst, src, len, wordOffset);
        }
        public static void ByteTo__CPU_MEMORY_SAVE(ref _CPU_MEMORY_SAVE[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__CPU_MEMORY_SAVE(dst, src, len, wordOffset);
        }
        public static void ByteTo__CPU_MEMORY_SAVE(ref _CPU_MEMORY_SAVE[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__CPU_MEMORY_SAVE(dst, src, len, wordOffset);
        }
        public static void ByteTo__CPU_MEMORY_SAVE(ref _CPU_MEMORY_SAVE[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__CPU_MEMORY_SAVE(dst, src, len, wordOffset);
        }
        public static void ByteTo__CPU_MEMORY_SAVE(ref _CPU_MEMORY_SAVE[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__CPU_MEMORY_SAVE(dst, src, len, wordOffset);
        }
        public static void ByteTo__CPU_MEMORY_SAVE(ref _CPU_MEMORY_SAVE[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__CPU_MEMORY_SAVE(dst, src, len, wordOffset);
        }
        public static void ByteTo__CPU_MEMORY_SAVE(ref _CPU_MEMORY_SAVE[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__CPU_MEMORY_SAVE(dst, src, len, wordOffset);
        }

        public static void ByteTo__DEV_INFO(ref _DEV_INFO dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUshort(ref dst.DevType, src, 1, 0 + wordOffset);
            ByteToUshort(ref dst.BitOffset, src, 1, 1 + wordOffset);
            ByteToUint(ref dst.DevNo, src, 1, 2 + wordOffset);
        }
        private static void ByteToBase__DEV_INFO(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _DEV_INFO elemTmp = new _DEV_INFO();
                NextIndices(dst, indices);
                ByteTo__DEV_INFO(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _DEV_INFO_WSIZE;
            }
        }
        public static void ByteTo__DEV_INFO(ref _DEV_INFO[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__DEV_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__DEV_INFO(ref _DEV_INFO[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__DEV_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__DEV_INFO(ref _DEV_INFO[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__DEV_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__DEV_INFO(ref _DEV_INFO[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__DEV_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__DEV_INFO(ref _DEV_INFO[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__DEV_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__DEV_INFO(ref _DEV_INFO[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__DEV_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__DEV_INFO(ref _DEV_INFO[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__DEV_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__DEV_INFO(ref _DEV_INFO[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__DEV_INFO(dst, src, len, wordOffset);
        }

        public static void ByteTo__EC_MASTER(ref _EC_MASTER dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBool(ref dst.MasterError, src, 1, 0 + wordOffset, 0);
            ByteToBool(ref dst.PDOActive, src, 1, 0 + wordOffset, 1);
            ByteToBool(ref dst.PDOInactive, src, 1, 0 + wordOffset, 2);
            ByteToBool(ref dst.PDOCommError, src, 1, 0 + wordOffset, 3);
            ByteToBool(ref dst.RingError, src, 1, 0 + wordOffset, 4);
            ByteToBool(ref dst.InDataInvalid, src, 1, 0 + wordOffset, 5);
            ByteToBool(ref dst.PDOParticipationTbl, src, 512, 1 + wordOffset, 0);
            ByteToBool(ref dst.PDOActiveTbl, src, 512, 33 + wordOffset, 0);
            ByteToBool(ref dst.PDOCommErrorTbl, src, 512, 65 + wordOffset, 0);
            ByteToBool(ref dst.SDOActiveTbl, src, 512, 97 + wordOffset, 0);
            ByteToBool(ref dst.RegTbl, src, 512, 129 + wordOffset, 0);
            ByteToBool(ref dst.ReserveTbl, src, 512, 161 + wordOffset, 0);
            ByteToBool(ref dst.PDOStopReqTbl, src, 512, 193 + wordOffset, 0);
            ByteToBool(ref dst.RingErrorTbl, src, 512, 225 + wordOffset, 0);
            ByteToUshort(ref dst.EcStateTbl, src, 512, 257 + wordOffset);
            ByteToUshort(ref dst.MasterErrorCode, src, 1, 769 + wordOffset);
            ByteToUshort(ref dst.MasterErrorDetail1, src, 1, 770 + wordOffset);
            ByteToUshort(ref dst.MasterErrorDetail2, src, 1, 771 + wordOffset);
        }
        private static void ByteToBase__EC_MASTER(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _EC_MASTER elemTmp = new _EC_MASTER();
                NextIndices(dst, indices);
                ByteTo__EC_MASTER(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _EC_MASTER_WSIZE;
            }
        }
        public static void ByteTo__EC_MASTER(ref _EC_MASTER[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__EC_MASTER(dst, src, len, wordOffset);
        }
        public static void ByteTo__EC_MASTER(ref _EC_MASTER[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__EC_MASTER(dst, src, len, wordOffset);
        }
        public static void ByteTo__EC_MASTER(ref _EC_MASTER[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__EC_MASTER(dst, src, len, wordOffset);
        }
        public static void ByteTo__EC_MASTER(ref _EC_MASTER[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__EC_MASTER(dst, src, len, wordOffset);
        }
        public static void ByteTo__EC_MASTER(ref _EC_MASTER[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__EC_MASTER(dst, src, len, wordOffset);
        }
        public static void ByteTo__EC_MASTER(ref _EC_MASTER[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__EC_MASTER(dst, src, len, wordOffset);
        }
        public static void ByteTo__EC_MASTER(ref _EC_MASTER[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__EC_MASTER(dst, src, len, wordOffset);
        }
        public static void ByteTo__EC_MASTER(ref _EC_MASTER[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__EC_MASTER(dst, src, len, wordOffset);
        }

        public static void ByteTo__EC_NODE(ref _EC_NODE dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUint(ref dst.VenderID, src, 1, 0 + wordOffset);
            ByteToUint(ref dst.ProductCode, src, 1, 2 + wordOffset);
            ByteToUint(ref dst.RevisionNo, src, 1, 4 + wordOffset);
            ByteToUint(ref dst.SerialNo, src, 1, 6 + wordOffset);
            ByteToUshort(ref dst.StationAlias, src, 1, 8 + wordOffset);
            ByteToUshort(ref dst.ConnectNodeNo, src, 4, 10 + wordOffset);
            ByteToUshort(ref dst.RxErrorCount, src, 4, 14 + wordOffset);
            ByteToUshort(ref dst.EmgMsgErrorCode, src, 1, 18 + wordOffset);
            ByteToUshort(ref dst.EmgMsgErrorReg, src, 1, 19 + wordOffset);
            ByteToUshort(ref dst.EmgMsgData0_1, src, 1, 20 + wordOffset);
            ByteToUshort(ref dst.EmgMsgData2_3, src, 1, 21 + wordOffset);
            ByteToUshort(ref dst.EmgMsgData4, src, 1, 22 + wordOffset);
            ByteToUshort(ref dst.NodeErrorCode, src, 1, 23 + wordOffset);
            ByteToUshort(ref dst.NodeErrorDetail1, src, 1, 24 + wordOffset);
            ByteToUshort(ref dst.NodeErrorDetail2, src, 1, 25 + wordOffset);
            ByteToUshort(ref dst.NodeWarning, src, 1, 26 + wordOffset);
            ByteToBool(ref dst.NodeError, src, 1, 27 + wordOffset, 0);
        }
        private static void ByteToBase__EC_NODE(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _EC_NODE elemTmp = new _EC_NODE();
                NextIndices(dst, indices);
                ByteTo__EC_NODE(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _EC_NODE_WSIZE;
            }
        }
        public static void ByteTo__EC_NODE(ref _EC_NODE[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__EC_NODE(dst, src, len, wordOffset);
        }
        public static void ByteTo__EC_NODE(ref _EC_NODE[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__EC_NODE(dst, src, len, wordOffset);
        }
        public static void ByteTo__EC_NODE(ref _EC_NODE[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__EC_NODE(dst, src, len, wordOffset);
        }
        public static void ByteTo__EC_NODE(ref _EC_NODE[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__EC_NODE(dst, src, len, wordOffset);
        }
        public static void ByteTo__EC_NODE(ref _EC_NODE[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__EC_NODE(dst, src, len, wordOffset);
        }
        public static void ByteTo__EC_NODE(ref _EC_NODE[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__EC_NODE(dst, src, len, wordOffset);
        }
        public static void ByteTo__EC_NODE(ref _EC_NODE[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__EC_NODE(dst, src, len, wordOffset);
        }
        public static void ByteTo__EC_NODE(ref _EC_NODE[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__EC_NODE(dst, src, len, wordOffset);
        }

        public static void ByteTo__ERROR_CTRL(ref _ERROR_CTRL dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBool(ref dst.Error, src, 1, 0 + wordOffset, 5);
            ByteToBool(ref dst.Warning, src, 1, 0 + wordOffset, 6);
            ByteToBool(ref dst.ClearCurrentError, src, 1, 0 + wordOffset, 9);
            ByteToBool(ref dst.ClearHistory, src, 1, 0 + wordOffset, 10);
        }
        private static void ByteToBase__ERROR_CTRL(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _ERROR_CTRL elemTmp = new _ERROR_CTRL();
                NextIndices(dst, indices);
                ByteTo__ERROR_CTRL(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _ERROR_CTRL_WSIZE;
            }
        }
        public static void ByteTo__ERROR_CTRL(ref _ERROR_CTRL[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__ERROR_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__ERROR_CTRL(ref _ERROR_CTRL[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__ERROR_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__ERROR_CTRL(ref _ERROR_CTRL[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__ERROR_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__ERROR_CTRL(ref _ERROR_CTRL[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__ERROR_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__ERROR_CTRL(ref _ERROR_CTRL[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__ERROR_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__ERROR_CTRL(ref _ERROR_CTRL[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__ERROR_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__ERROR_CTRL(ref _ERROR_CTRL[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__ERROR_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__ERROR_CTRL(ref _ERROR_CTRL[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__ERROR_CTRL(dst, src, len, wordOffset);
        }

        public static void ByteTo__ERROR_DETAIL(ref _ERROR_DETAIL dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUshort(ref dst.YearMonth, src, 1, 0 + wordOffset);
            ByteToUshort(ref dst.Day, src, 1, 1 + wordOffset);
            ByteToUshort(ref dst.Hour, src, 1, 2 + wordOffset);
            ByteToUshort(ref dst.Minute, src, 1, 3 + wordOffset);
            ByteToUshort(ref dst.Second, src, 1, 4 + wordOffset);
            ByteToUshort(ref dst.ErrorNumber, src, 1, 5 + wordOffset);
            ByteToUshort(ref dst.ValidCount, src, 1, 6 + wordOffset);
            ByteToUshort(ref dst.Detail, src, 20, 7 + wordOffset);
        }
        private static void ByteToBase__ERROR_DETAIL(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _ERROR_DETAIL elemTmp = new _ERROR_DETAIL();
                NextIndices(dst, indices);
                ByteTo__ERROR_DETAIL(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _ERROR_DETAIL_WSIZE;
            }
        }
        public static void ByteTo__ERROR_DETAIL(ref _ERROR_DETAIL[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__ERROR_DETAIL(dst, src, len, wordOffset);
        }
        public static void ByteTo__ERROR_DETAIL(ref _ERROR_DETAIL[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__ERROR_DETAIL(dst, src, len, wordOffset);
        }
        public static void ByteTo__ERROR_DETAIL(ref _ERROR_DETAIL[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__ERROR_DETAIL(dst, src, len, wordOffset);
        }
        public static void ByteTo__ERROR_DETAIL(ref _ERROR_DETAIL[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__ERROR_DETAIL(dst, src, len, wordOffset);
        }
        public static void ByteTo__ERROR_DETAIL(ref _ERROR_DETAIL[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__ERROR_DETAIL(dst, src, len, wordOffset);
        }
        public static void ByteTo__ERROR_DETAIL(ref _ERROR_DETAIL[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__ERROR_DETAIL(dst, src, len, wordOffset);
        }
        public static void ByteTo__ERROR_DETAIL(ref _ERROR_DETAIL[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__ERROR_DETAIL(dst, src, len, wordOffset);
        }
        public static void ByteTo__ERROR_DETAIL(ref _ERROR_DETAIL[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__ERROR_DETAIL(dst, src, len, wordOffset);
        }

        public static void ByteTo__EXPANSION_UNIT(ref _EXPANSION_UNIT dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBool(ref dst.Connected, src, 49, 0 + wordOffset, 0);
            ByteToBool(ref dst.LoadOption, src, 49, 4 + wordOffset, 0);
            ByteToUshort(ref dst.UnitNumber, src, 1, 75 + wordOffset);
        }
        private static void ByteToBase__EXPANSION_UNIT(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _EXPANSION_UNIT elemTmp = new _EXPANSION_UNIT();
                NextIndices(dst, indices);
                ByteTo__EXPANSION_UNIT(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _EXPANSION_UNIT_WSIZE;
            }
        }
        public static void ByteTo__EXPANSION_UNIT(ref _EXPANSION_UNIT[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__EXPANSION_UNIT(dst, src, len, wordOffset);
        }
        public static void ByteTo__EXPANSION_UNIT(ref _EXPANSION_UNIT[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__EXPANSION_UNIT(dst, src, len, wordOffset);
        }
        public static void ByteTo__EXPANSION_UNIT(ref _EXPANSION_UNIT[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__EXPANSION_UNIT(dst, src, len, wordOffset);
        }
        public static void ByteTo__EXPANSION_UNIT(ref _EXPANSION_UNIT[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__EXPANSION_UNIT(dst, src, len, wordOffset);
        }
        public static void ByteTo__EXPANSION_UNIT(ref _EXPANSION_UNIT[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__EXPANSION_UNIT(dst, src, len, wordOffset);
        }
        public static void ByteTo__EXPANSION_UNIT(ref _EXPANSION_UNIT[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__EXPANSION_UNIT(dst, src, len, wordOffset);
        }
        public static void ByteTo__EXPANSION_UNIT(ref _EXPANSION_UNIT[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__EXPANSION_UNIT(dst, src, len, wordOffset);
        }
        public static void ByteTo__EXPANSION_UNIT(ref _EXPANSION_UNIT[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__EXPANSION_UNIT(dst, src, len, wordOffset);
        }

        public static void ByteTo__FILE_STATUS(ref _FILE_STATUS dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUshort(ref dst.ModifiedDate, src, 6, 0 + wordOffset);
            ByteToUint(ref dst.FileSize, src, 1, 6 + wordOffset);
            ByteToBool(ref dst.ReadOnly, src, 1, 8 + wordOffset, 0);
            ByteToBool(ref dst.HiddenFile, src, 1, 8 + wordOffset, 1);
            ByteToBool(ref dst.SystemFile, src, 1, 8 + wordOffset, 2);
            ByteToBool(ref dst.VolumeLabel, src, 1, 8 + wordOffset, 3);
            ByteToBool(ref dst.Folder, src, 1, 8 + wordOffset, 4);
            ByteToBool(ref dst.Archive, src, 1, 8 + wordOffset, 5);
            ByteToUshort(ref dst.Reserved, src, 1, 9 + wordOffset);
        }
        private static void ByteToBase__FILE_STATUS(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _FILE_STATUS elemTmp = new _FILE_STATUS();
                NextIndices(dst, indices);
                ByteTo__FILE_STATUS(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _FILE_STATUS_WSIZE;
            }
        }
        public static void ByteTo__FILE_STATUS(ref _FILE_STATUS[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__FILE_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__FILE_STATUS(ref _FILE_STATUS[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__FILE_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__FILE_STATUS(ref _FILE_STATUS[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__FILE_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__FILE_STATUS(ref _FILE_STATUS[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__FILE_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__FILE_STATUS(ref _FILE_STATUS[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__FILE_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__FILE_STATUS(ref _FILE_STATUS[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__FILE_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__FILE_STATUS(ref _FILE_STATUS[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__FILE_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__FILE_STATUS(ref _FILE_STATUS[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__FILE_STATUS(dst, src, len, wordOffset);
        }

        public static void ByteTo__LOGGING_TRACE(ref _LOGGING_TRACE dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBool(ref dst.ExecEnable, src, 1, 0 + wordOffset, 0);
            ByteToBool(ref dst.InOperation, src, 1, 0 + wordOffset, 1);
            ByteToBool(ref dst.FileWriteEnd, src, 1, 0 + wordOffset, 2);
            ByteToBool(ref dst.BufferHalfAlm, src, 1, 0 + wordOffset, 3);
            ByteToBool(ref dst.BufferOverflow, src, 1, 0 + wordOffset, 4);
            ByteToBool(ref dst.WriteDuringRun, src, 1, 0 + wordOffset, 5);
            ByteToBool(ref dst.LoggingTraceError, src, 1, 0 + wordOffset, 8);
            ByteToBool(ref dst.NoMemoryCapacity, src, 1, 0 + wordOffset, 9);
            ByteToBool(ref dst.DeviceTriggerSetError, src, 1, 0 + wordOffset, 10);
            ByteToBool(ref dst.FileSaveTriggerMonitor, src, 1, 0 + wordOffset, 11);
            ByteToBool(ref dst.DataAcquireComplete, src, 1, 0 + wordOffset, 12);
            ByteToUshort(ref dst.MinBufferSpace, src, 1, 1 + wordOffset);
            ByteToUshort(ref dst.LoopBufferSpace, src, 1, 2 + wordOffset);
            ByteToUshort(ref dst.FileSavingCounter, src, 1, 3 + wordOffset);
            ByteToUshort(ref dst.Reserved, src, 6, 4 + wordOffset);
        }
        private static void ByteToBase__LOGGING_TRACE(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _LOGGING_TRACE elemTmp = new _LOGGING_TRACE();
                NextIndices(dst, indices);
                ByteTo__LOGGING_TRACE(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _LOGGING_TRACE_WSIZE;
            }
        }
        public static void ByteTo__LOGGING_TRACE(ref _LOGGING_TRACE[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__LOGGING_TRACE(dst, src, len, wordOffset);
        }
        public static void ByteTo__LOGGING_TRACE(ref _LOGGING_TRACE[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__LOGGING_TRACE(dst, src, len, wordOffset);
        }
        public static void ByteTo__LOGGING_TRACE(ref _LOGGING_TRACE[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__LOGGING_TRACE(dst, src, len, wordOffset);
        }
        public static void ByteTo__LOGGING_TRACE(ref _LOGGING_TRACE[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__LOGGING_TRACE(dst, src, len, wordOffset);
        }
        public static void ByteTo__LOGGING_TRACE(ref _LOGGING_TRACE[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__LOGGING_TRACE(dst, src, len, wordOffset);
        }
        public static void ByteTo__LOGGING_TRACE(ref _LOGGING_TRACE[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__LOGGING_TRACE(dst, src, len, wordOffset);
        }
        public static void ByteTo__LOGGING_TRACE(ref _LOGGING_TRACE[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__LOGGING_TRACE(dst, src, len, wordOffset);
        }
        public static void ByteTo__LOGGING_TRACE(ref _LOGGING_TRACE[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__LOGGING_TRACE(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_AXIS_CFG(ref _MC_AXIS_CFG dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUshort(ref dst.UnitCoordTrans, src, 1, 0 + wordOffset);
            ByteToDouble(ref dst.PosCycle, src, 1, 4 + wordOffset);
            ByteToUint(ref dst.CoordTransDenominator, src, 1, 12 + wordOffset);
            ByteToUint(ref dst.CoordTransNumerator, src, 1, 14 + wordOffset);
            ByteToUshort(ref dst.SoftLimitCoordSystem, src, 1, 16 + wordOffset);
            ByteToUshort(ref dst.UseSoftLimit, src, 1, 17 + wordOffset);
            ByteToDouble(ref dst.SoftLimitPositivePos, src, 1, 20 + wordOffset);
            ByteToDouble(ref dst.SoftLimitNegativePos, src, 1, 24 + wordOffset);
            ByteToUshort(ref dst.AxisErrorSetting, src, 1, 28 + wordOffset);
            ByteToUshort(ref dst.AxisCtrlSetting, src, 1, 29 + wordOffset);
            ByteToUshort(ref dst.ServoEndCheckTime, src, 1, 30 + wordOffset);
            ByteToDouble(ref dst.BacklashCompensationMovement, src, 1, 32 + wordOffset);
            ByteToDouble(ref dst.ServoEndRange, src, 1, 36 + wordOffset);
            ByteToUshort(ref dst.ChgToPosCtrlModeVelThresh, src, 1, 40 + wordOffset);
            ByteToInt(ref dst.AbsEncUpperLim, src, 1, 42 + wordOffset);
            ByteToInt(ref dst.AbsEncLowerLim, src, 1, 44 + wordOffset);
            ByteToUshort(ref dst.Reserved, src, 54, 46 + wordOffset);
        }
        private static void ByteToBase__MC_AXIS_CFG(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_AXIS_CFG elemTmp = new _MC_AXIS_CFG();
                NextIndices(dst, indices);
                ByteTo__MC_AXIS_CFG(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_AXIS_CFG_WSIZE;
            }
        }
        public static void ByteTo__MC_AXIS_CFG(ref _MC_AXIS_CFG[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_CFG(ref _MC_AXIS_CFG[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_CFG(ref _MC_AXIS_CFG[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_CFG(ref _MC_AXIS_CFG[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_CFG(ref _MC_AXIS_CFG[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_CFG(ref _MC_AXIS_CFG[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_CFG(ref _MC_AXIS_CFG[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_CFG(ref _MC_AXIS_CFG[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_CFG(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_AXIS_CMP_CODE(ref _MC_AXIS_CMP_CODE dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUshort(ref dst.PosCtrlStart, src, 1, 2 + wordOffset);
            ByteToUshort(ref dst.SetPosition, src, 1, 4 + wordOffset);
            ByteToUshort(ref dst.ChgTargetPos, src, 1, 5 + wordOffset);
            ByteToUshort(ref dst.ChgTargetVel, src, 1, 6 + wordOffset);
            ByteToUshort(ref dst.Stop, src, 1, 7 + wordOffset);
            ByteToUshort(ref dst.RestartPositioning, src, 1, 8 + wordOffset);
            ByteToUshort(ref dst.MoveToNextPoint, src, 1, 9 + wordOffset);
            ByteToUshort(ref dst.SuspendNextPositioning, src, 1, 10 + wordOffset);
            ByteToUshort(ref dst.StopAtTargetPosition, src, 1, 11 + wordOffset);
            ByteToUshort(ref dst.Homing, src, 1, 12 + wordOffset);
            ByteToUshort(ref dst.MoveToBasePosition, src, 1, 13 + wordOffset);
            ByteToUshort(ref dst.FastMoveToHome, src, 1, 14 + wordOffset);
            ByteToUshort(ref dst.Teaching, src, 1, 15 + wordOffset);
            ByteToUshort(ref dst.StartSpecialFunc, src, 1, 17 + wordOffset);
            ByteToUshort(ref dst.ReleaseSpecialFunc, src, 1, 18 + wordOffset);
            ByteToUshort(ref dst.ChgCtrlMode, src, 1, 19 + wordOffset);
            ByteToUshort(ref dst.StartSyncCtrl, src, 1, 20 + wordOffset);
            ByteToUshort(ref dst.ReleaseSyncCtrl, src, 1, 21 + wordOffset);
            ByteToUshort(ref dst.ChgCam, src, 1, 22 + wordOffset);
            ByteToUshort(ref dst.ReengageSyncTrqLimitClutch, src, 1, 23 + wordOffset);
        }
        private static void ByteToBase__MC_AXIS_CMP_CODE(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_AXIS_CMP_CODE elemTmp = new _MC_AXIS_CMP_CODE();
                NextIndices(dst, indices);
                ByteTo__MC_AXIS_CMP_CODE(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_AXIS_CMP_CODE_WSIZE;
            }
        }
        public static void ByteTo__MC_AXIS_CMP_CODE(ref _MC_AXIS_CMP_CODE[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_CMP_CODE(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_CMP_CODE(ref _MC_AXIS_CMP_CODE[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_CMP_CODE(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_CMP_CODE(ref _MC_AXIS_CMP_CODE[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_CMP_CODE(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_CMP_CODE(ref _MC_AXIS_CMP_CODE[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_CMP_CODE(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_CMP_CODE(ref _MC_AXIS_CMP_CODE[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_CMP_CODE(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_CMP_CODE(ref _MC_AXIS_CMP_CODE[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_CMP_CODE(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_CMP_CODE(ref _MC_AXIS_CMP_CODE[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_CMP_CODE(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_CMP_CODE(ref _MC_AXIS_CMP_CODE[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_CMP_CODE(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_AXIS_CTRL(ref _MC_AXIS_CTRL dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUshort(ref dst.PointNo, src, 1, 0 + wordOffset);
            ByteToUshort(ref dst.CtrlMode, src, 1, 1 + wordOffset);
            ByteToDouble(ref dst.SetPosition, src, 1, 4 + wordOffset);
            ByteToDouble(ref dst.ChgPositioningTargetPos, src, 1, 8 + wordOffset);
            ByteToDouble(ref dst.ChgPositioningTargetVel, src, 1, 12 + wordOffset);
            ByteToDouble(ref dst.ChgVel, src, 1, 16 + wordOffset);
            ByteToUshort(ref dst.Override, src, 1, 20 + wordOffset);
            ByteToUshort(ref dst.SelectSpecialFunc, src, 1, 21 + wordOffset);
            ByteToDouble(ref dst.AbsPosFollowUpCtrlCmdVal, src, 1, 24 + wordOffset);
            ByteToDouble(ref dst.SyncTypeFollowUpCtrlCmdVal, src, 1, 28 + wordOffset);
            ByteToDouble(ref dst.VelCtrlCmdVel, src, 1, 32 + wordOffset);
            ByteToDouble(ref dst.VelCtrlTrqLimit, src, 1, 36 + wordOffset);
            ByteToDouble(ref dst.VelCtrlTrqFeedforward, src, 1, 40 + wordOffset);
            ByteToDouble(ref dst.TrqCtrlCmdTrq, src, 1, 44 + wordOffset);
            ByteToDouble(ref dst.TrqCtrlVelLimit, src, 1, 48 + wordOffset);
            ByteToDouble(ref dst.PosCtrlTrqLimit, src, 1, 52 + wordOffset);
            ByteToDouble(ref dst.PosCtrlVelFeedforward, src, 1, 56 + wordOffset);
            ByteToDouble(ref dst.PosCtrlTrqFeedforward, src, 1, 60 + wordOffset);
            ByteToUshort(ref dst.ChgSyncCamNo, src, 1, 64 + wordOffset);
            ByteToUshort(ref dst.ChgSyncCamPos, src, 1, 65 + wordOffset);
            ByteToUshort(ref dst.Controlword, src, 1, 68 + wordOffset);
            ByteToUshort(ref dst.TouchProbeFunction, src, 1, 69 + wordOffset);
            ByteToUshort(ref dst.Reserved, src, 30, 70 + wordOffset);
        }
        private static void ByteToBase__MC_AXIS_CTRL(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_AXIS_CTRL elemTmp = new _MC_AXIS_CTRL();
                NextIndices(dst, indices);
                ByteTo__MC_AXIS_CTRL(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_AXIS_CTRL_WSIZE;
            }
        }
        public static void ByteTo__MC_AXIS_CTRL(ref _MC_AXIS_CTRL[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_CTRL(ref _MC_AXIS_CTRL[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_CTRL(ref _MC_AXIS_CTRL[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_CTRL(ref _MC_AXIS_CTRL[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_CTRL(ref _MC_AXIS_CTRL[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_CTRL(ref _MC_AXIS_CTRL[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_CTRL(ref _MC_AXIS_CTRL[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_CTRL(ref _MC_AXIS_CTRL[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_CTRL(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_AXIS_GROUP_CFG(ref _MC_AXIS_GROUP_CFG dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUshort(ref dst.Axis, src, 16, 0 + wordOffset);
        }
        private static void ByteToBase__MC_AXIS_GROUP_CFG(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_AXIS_GROUP_CFG elemTmp = new _MC_AXIS_GROUP_CFG();
                NextIndices(dst, indices);
                ByteTo__MC_AXIS_GROUP_CFG(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_AXIS_GROUP_CFG_WSIZE;
            }
        }
        public static void ByteTo__MC_AXIS_GROUP_CFG(ref _MC_AXIS_GROUP_CFG[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_GROUP_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_GROUP_CFG(ref _MC_AXIS_GROUP_CFG[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_GROUP_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_GROUP_CFG(ref _MC_AXIS_GROUP_CFG[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_GROUP_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_GROUP_CFG(ref _MC_AXIS_GROUP_CFG[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_GROUP_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_GROUP_CFG(ref _MC_AXIS_GROUP_CFG[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_GROUP_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_GROUP_CFG(ref _MC_AXIS_GROUP_CFG[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_GROUP_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_GROUP_CFG(ref _MC_AXIS_GROUP_CFG[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_GROUP_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_GROUP_CFG(ref _MC_AXIS_GROUP_CFG[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_GROUP_CFG(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_AXIS_GROUP_REF(ref _MC_AXIS_GROUP_REF dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUshort(ref dst.AxisGroupNo, src, 1, 0 + wordOffset);
        }
        private static void ByteToBase__MC_AXIS_GROUP_REF(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_AXIS_GROUP_REF elemTmp = new _MC_AXIS_GROUP_REF();
                NextIndices(dst, indices);
                ByteTo__MC_AXIS_GROUP_REF(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_AXIS_GROUP_REF_WSIZE;
            }
        }
        public static void ByteTo__MC_AXIS_GROUP_REF(ref _MC_AXIS_GROUP_REF[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_GROUP_REF(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_GROUP_REF(ref _MC_AXIS_GROUP_REF[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_GROUP_REF(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_GROUP_REF(ref _MC_AXIS_GROUP_REF[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_GROUP_REF(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_GROUP_REF(ref _MC_AXIS_GROUP_REF[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_GROUP_REF(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_GROUP_REF(ref _MC_AXIS_GROUP_REF[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_GROUP_REF(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_GROUP_REF(ref _MC_AXIS_GROUP_REF[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_GROUP_REF(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_GROUP_REF(ref _MC_AXIS_GROUP_REF[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_GROUP_REF(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_GROUP_REF(ref _MC_AXIS_GROUP_REF[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_GROUP_REF(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_AXIS_IO_STATUS(ref _MC_AXIS_IO_STATUS dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBool(ref dst.PositiveLimit, src, 1, 0 + wordOffset, 0);
            ByteToBool(ref dst.NegativeLimit, src, 1, 0 + wordOffset, 1);
            ByteToBool(ref dst.HomeSensor, src, 1, 0 + wordOffset, 2);
            ByteToBool(ref dst.StopSensor, src, 1, 0 + wordOffset, 3);
            ByteToBool(ref dst.SyncCtrlExtInput, src, 1, 0 + wordOffset, 4);
            ByteToBool(ref dst.ServoEnd, src, 1, 0 + wordOffset, 6);
            ByteToBool(ref dst.ServoReady, src, 1, 0 + wordOffset, 7);
            ByteToBool(ref dst.DrvAlarm, src, 1, 0 + wordOffset, 8);
            ByteToBool(ref dst.ServoOn, src, 1, 0 + wordOffset, 14);
            ByteToBool(ref dst.Reserved, src, 1, 0 + wordOffset, 15);
        }
        private static void ByteToBase__MC_AXIS_IO_STATUS(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_AXIS_IO_STATUS elemTmp = new _MC_AXIS_IO_STATUS();
                NextIndices(dst, indices);
                ByteTo__MC_AXIS_IO_STATUS(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_AXIS_IO_STATUS_WSIZE;
            }
        }
        public static void ByteTo__MC_AXIS_IO_STATUS(ref _MC_AXIS_IO_STATUS[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_IO_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_IO_STATUS(ref _MC_AXIS_IO_STATUS[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_IO_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_IO_STATUS(ref _MC_AXIS_IO_STATUS[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_IO_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_IO_STATUS(ref _MC_AXIS_IO_STATUS[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_IO_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_IO_STATUS(ref _MC_AXIS_IO_STATUS[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_IO_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_IO_STATUS(ref _MC_AXIS_IO_STATUS[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_IO_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_IO_STATUS(ref _MC_AXIS_IO_STATUS[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_IO_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_IO_STATUS(ref _MC_AXIS_IO_STATUS[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_IO_STATUS(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_AXIS_MOTION_FUNC_MAP(ref _MC_AXIS_MOTION_FUNC_MAP dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBool(ref dst.PosCtrlAvl, src, 1, 0 + wordOffset, 0);
            ByteToBool(ref dst.VelCtrlAvl, src, 1, 0 + wordOffset, 1);
            ByteToBool(ref dst.TrqCtrlAvl, src, 1, 0 + wordOffset, 2);
            ByteToBool(ref dst.FeedbackTrqAvl, src, 1, 0 + wordOffset, 3);
            ByteToBool(ref dst.StopSensorAvl, src, 1, 0 + wordOffset, 4);
            ByteToBool(ref dst.HomingBaseAvl, src, 1, 0 + wordOffset, 8);
            ByteToBool(ref dst.HomingDogNoZAvl, src, 1, 0 + wordOffset, 9);
            ByteToBool(ref dst.HomingDogPressAvl, src, 1, 0 + wordOffset, 10);
            ByteToBool(ref dst.HomingLimitSwAvl, src, 1, 0 + wordOffset, 11);
            ByteToBool(ref dst.HomingImmZAvl, src, 1, 0 + wordOffset, 12);
            ByteToBool(ref dst.PosCtrlTrqLimitAvl, src, 1, 1 + wordOffset, 0);
            ByteToBool(ref dst.PosCtrlVelFeedforwardAvl, src, 1, 1 + wordOffset, 1);
            ByteToBool(ref dst.PosCtrlTrqFeedforwardAvl, src, 1, 1 + wordOffset, 2);
            ByteToBool(ref dst.VelCtrlTrqLimitAvl, src, 1, 1 + wordOffset, 3);
            ByteToBool(ref dst.VelCtrlTrqFeedforwardAvl, src, 1, 1 + wordOffset, 4);
            ByteToBool(ref dst.TrqCtrlVelLimitAvl, src, 1, 1 + wordOffset, 5);
            ByteToBool(ref dst.DrvAlarmCodeAvl, src, 1, 1 + wordOffset, 6);
            ByteToBool(ref dst.Reserved, src, 9, 1 + wordOffset, 7);
        }
        private static void ByteToBase__MC_AXIS_MOTION_FUNC_MAP(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_AXIS_MOTION_FUNC_MAP elemTmp = new _MC_AXIS_MOTION_FUNC_MAP();
                NextIndices(dst, indices);
                ByteTo__MC_AXIS_MOTION_FUNC_MAP(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_AXIS_MOTION_FUNC_MAP_WSIZE;
            }
        }
        public static void ByteTo__MC_AXIS_MOTION_FUNC_MAP(ref _MC_AXIS_MOTION_FUNC_MAP[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_MOTION_FUNC_MAP(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_MOTION_FUNC_MAP(ref _MC_AXIS_MOTION_FUNC_MAP[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_MOTION_FUNC_MAP(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_MOTION_FUNC_MAP(ref _MC_AXIS_MOTION_FUNC_MAP[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_MOTION_FUNC_MAP(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_MOTION_FUNC_MAP(ref _MC_AXIS_MOTION_FUNC_MAP[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_MOTION_FUNC_MAP(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_MOTION_FUNC_MAP(ref _MC_AXIS_MOTION_FUNC_MAP[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_MOTION_FUNC_MAP(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_MOTION_FUNC_MAP(ref _MC_AXIS_MOTION_FUNC_MAP[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_MOTION_FUNC_MAP(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_MOTION_FUNC_MAP(ref _MC_AXIS_MOTION_FUNC_MAP[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_MOTION_FUNC_MAP(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_MOTION_FUNC_MAP(ref _MC_AXIS_MOTION_FUNC_MAP[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_MOTION_FUNC_MAP(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_AXIS_STATUS(ref _MC_AXIS_STATUS dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUshort(ref dst.ErrorCode, src, 1, 0 + wordOffset);
            ByteToUshort(ref dst.ErrorDetail, src, 5, 1 + wordOffset);
            ByteToUshort(ref dst.WarningCode, src, 1, 6 + wordOffset);
            ByteToUshort(ref dst.WarningDetail, src, 5, 7 + wordOffset);
            ByteTo__MC_AXIS_IO_STATUS(ref dst.IOStatus, src, 1, 12 + wordOffset);
            ByteToUshort(ref dst.PosCtrlState, src, 1, 13 + wordOffset);
            ByteToDouble(ref dst.CmdPos, src, 1, 16 + wordOffset);
            ByteToDouble(ref dst.CmdVel, src, 1, 20 + wordOffset);
            ByteToInt(ref dst.CmdPls, src, 1, 24 + wordOffset);
            ByteToDouble(ref dst.MechanicalPos, src, 1, 28 + wordOffset);
            ByteToUshort(ref dst.CurrentPointNo, src, 1, 32 + wordOffset);
            ByteToUshort(ref dst.MCode, src, 1, 33 + wordOffset);
            ByteToDouble(ref dst.TargetPos, src, 1, 36 + wordOffset);
            ByteToDouble(ref dst.InheritedVel, src, 1, 40 + wordOffset);
            ByteToUshort(ref dst.CurrentCtrlMode, src, 1, 45 + wordOffset);
            ByteToInt(ref dst.FeedbackPls, src, 1, 46 + wordOffset);
            ByteToDouble(ref dst.ActPos, src, 1, 48 + wordOffset);
            ByteToDouble(ref dst.ActVel, src, 1, 52 + wordOffset);
            ByteToUshort(ref dst.DrvAlarmCode, src, 1, 56 + wordOffset);
            ByteToInt(ref dst.EcatStatus, src, 1, 58 + wordOffset);
            ByteToUshort(ref dst.DrvAlarmDetail1, src, 1, 60 + wordOffset);
            ByteToUshort(ref dst.DrvAlarmDetail2, src, 1, 61 + wordOffset);
            ByteToUshort(ref dst.EcatNodeAdr, src, 1, 62 + wordOffset);
            ByteToUshort(ref dst.AxisIndex, src, 1, 63 + wordOffset);
            ByteToDouble(ref dst.TrqLimitMon, src, 1, 64 + wordOffset);
            ByteToDouble(ref dst.TrqFeedforwardMon, src, 1, 68 + wordOffset);
            ByteToDouble(ref dst.VelLimitMon, src, 1, 72 + wordOffset);
            ByteToDouble(ref dst.VelFeedforwardMon, src, 1, 76 + wordOffset);
            ByteToDouble(ref dst.FeedbackVel, src, 1, 80 + wordOffset);
            ByteToDouble(ref dst.FeedbackTrq, src, 1, 84 + wordOffset);
            ByteToInt(ref dst.PosDeviation, src, 1, 88 + wordOffset);
            ByteToUshort(ref dst.CurrentSettlingTime, src, 1, 90 + wordOffset);
            ByteToUshort(ref dst.MaxSettlingTime, src, 1, 91 + wordOffset);
            ByteTo__MC_AXIS_MOTION_FUNC_MAP(ref dst.MotionFuncMapSetting, src, 1, 92 + wordOffset);
            ByteToUshort(ref dst.StopSensorDetectionNum, src, 1, 94 + wordOffset);
            ByteToDouble(ref dst.StopSensorPos, src, 1, 96 + wordOffset);
            ByteToUshort(ref dst.Reserved, src, 12, 100 + wordOffset);
        }
        private static void ByteToBase__MC_AXIS_STATUS(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_AXIS_STATUS elemTmp = new _MC_AXIS_STATUS();
                NextIndices(dst, indices);
                ByteTo__MC_AXIS_STATUS(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_AXIS_STATUS_WSIZE;
            }
        }
        public static void ByteTo__MC_AXIS_STATUS(ref _MC_AXIS_STATUS[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_STATUS(ref _MC_AXIS_STATUS[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_STATUS(ref _MC_AXIS_STATUS[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_STATUS(ref _MC_AXIS_STATUS[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_STATUS(ref _MC_AXIS_STATUS[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_STATUS(ref _MC_AXIS_STATUS[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_STATUS(ref _MC_AXIS_STATUS[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_STATUS(ref _MC_AXIS_STATUS[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_STATUS(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_AXIS_STATUS_BIT(ref _MC_AXIS_STATUS_BIT dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBool(ref dst.PlsOutputDone, src, 1, 0 + wordOffset, 1);
            ByteToBool(ref dst.PositioningDone, src, 1, 0 + wordOffset, 2);
            ByteToBool(ref dst.MCodeStatus, src, 1, 0 + wordOffset, 7);
            ByteToBool(ref dst.AxisError, src, 1, 1 + wordOffset, 0);
            ByteToBool(ref dst.AxisWarning, src, 1, 1 + wordOffset, 1);
            ByteToBool(ref dst.InControl, src, 1, 1 + wordOffset, 3);
            ByteToBool(ref dst.ServoEnd, src, 1, 1 + wordOffset, 4);
            ByteToBool(ref dst.ServoReady, src, 1, 1 + wordOffset, 5);
            ByteToBool(ref dst.DrvAlarm, src, 1, 1 + wordOffset, 6);
            ByteToBool(ref dst.Jogging, src, 1, 1 + wordOffset, 13);
            ByteToBool(ref dst.HomeIsNotDefined, src, 1, 1 + wordOffset, 15);
            ByteToBool(ref dst.InSyncCtrl, src, 1, 2 + wordOffset, 2);
            ByteToBool(ref dst.MainClutchStatus, src, 1, 2 + wordOffset, 3);
            ByteToBool(ref dst.ChangingMainAxisPhaseCompensation, src, 1, 2 + wordOffset, 4);
            ByteToBool(ref dst.MainClutchEngaged, src, 1, 2 + wordOffset, 5);
            ByteToBool(ref dst.AuxClutchStatus, src, 1, 2 + wordOffset, 8);
            ByteToBool(ref dst.ChangingAuxAxisPhaseCompensation, src, 1, 2 + wordOffset, 9);
            ByteToBool(ref dst.AuxClutchEngaged, src, 1, 2 + wordOffset, 10);
            ByteToBool(ref dst.ChangingSyncVariableGear, src, 1, 2 + wordOffset, 13);
            ByteToBool(ref dst.TrqLimitClutchOff, src, 1, 3 + wordOffset, 1);
            ByteToBool(ref dst.DrvLimit, src, 1, 3 + wordOffset, 2);
            ByteToBool(ref dst.DrvWarning, src, 1, 3 + wordOffset, 6);
            ByteToBool(ref dst.Reserved, src, 64, 4 + wordOffset, 0);
        }
        private static void ByteToBase__MC_AXIS_STATUS_BIT(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_AXIS_STATUS_BIT elemTmp = new _MC_AXIS_STATUS_BIT();
                NextIndices(dst, indices);
                ByteTo__MC_AXIS_STATUS_BIT(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_AXIS_STATUS_BIT_WSIZE;
            }
        }
        public static void ByteTo__MC_AXIS_STATUS_BIT(ref _MC_AXIS_STATUS_BIT[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_STATUS_BIT(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_STATUS_BIT(ref _MC_AXIS_STATUS_BIT[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_STATUS_BIT(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_STATUS_BIT(ref _MC_AXIS_STATUS_BIT[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_STATUS_BIT(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_STATUS_BIT(ref _MC_AXIS_STATUS_BIT[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_STATUS_BIT(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_STATUS_BIT(ref _MC_AXIS_STATUS_BIT[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_STATUS_BIT(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_STATUS_BIT(ref _MC_AXIS_STATUS_BIT[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_STATUS_BIT(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_STATUS_BIT(ref _MC_AXIS_STATUS_BIT[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_STATUS_BIT(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_STATUS_BIT(ref _MC_AXIS_STATUS_BIT[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_STATUS_BIT(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_AXIS_SYNC_STATUS(ref _MC_AXIS_SYNC_STATUS dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToDouble(ref dst.MainAxisPhaseCompensation, src, 1, 4 + wordOffset);
            ByteToDouble(ref dst.AuxAxisPhaseCompensation, src, 1, 8 + wordOffset);
            ByteToDouble(ref dst.StepAngleCompensation, src, 1, 12 + wordOffset);
            ByteToDouble(ref dst.MainAxisPhase, src, 1, 16 + wordOffset);
            ByteToDouble(ref dst.MainClutchInputAxisPhase, src, 1, 20 + wordOffset);
            ByteToDouble(ref dst.MainClutchInputAxisPos, src, 1, 24 + wordOffset);
            ByteToDouble(ref dst.MainClutchOutputAxisPhase, src, 1, 28 + wordOffset);
            ByteToDouble(ref dst.MainClutchOutputAxisPos, src, 1, 32 + wordOffset);
            ByteToDouble(ref dst.AuxClutchInputAxisPhase, src, 1, 36 + wordOffset);
            ByteToDouble(ref dst.AuxClutchInputAxisPos, src, 1, 40 + wordOffset);
            ByteToDouble(ref dst.AuxClutchOutputAxisPhase, src, 1, 44 + wordOffset);
            ByteToDouble(ref dst.AuxClutchOutputAxisPos, src, 1, 48 + wordOffset);
            ByteToDouble(ref dst.TrqLimitClutchInputAxisPhase, src, 1, 52 + wordOffset);
            ByteToDouble(ref dst.TrqLimitClutchInputAxisPos, src, 1, 56 + wordOffset);
            ByteToDouble(ref dst.TrqLimitClutchOutputAxisPhase, src, 1, 60 + wordOffset);
            ByteToDouble(ref dst.TrqLimitClutchOutputAxisPos, src, 1, 64 + wordOffset);
            ByteToDouble(ref dst.CamInputAxisPhase, src, 1, 68 + wordOffset);
            ByteToDouble(ref dst.CamOutputRelativePos, src, 1, 72 + wordOffset);
            ByteToUshort(ref dst.CurrentCamNo, src, 1, 76 + wordOffset);
            ByteToUshort(ref dst.ContactOutputCurrentParamNo, src, 1, 77 + wordOffset);
            ByteToUshort(ref dst.Reserved, src, 2, 78 + wordOffset);
        }
        private static void ByteToBase__MC_AXIS_SYNC_STATUS(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_AXIS_SYNC_STATUS elemTmp = new _MC_AXIS_SYNC_STATUS();
                NextIndices(dst, indices);
                ByteTo__MC_AXIS_SYNC_STATUS(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_AXIS_SYNC_STATUS_WSIZE;
            }
        }
        public static void ByteTo__MC_AXIS_SYNC_STATUS(ref _MC_AXIS_SYNC_STATUS[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_SYNC_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_SYNC_STATUS(ref _MC_AXIS_SYNC_STATUS[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_SYNC_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_SYNC_STATUS(ref _MC_AXIS_SYNC_STATUS[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_SYNC_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_SYNC_STATUS(ref _MC_AXIS_SYNC_STATUS[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_SYNC_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_SYNC_STATUS(ref _MC_AXIS_SYNC_STATUS[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_SYNC_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_SYNC_STATUS(ref _MC_AXIS_SYNC_STATUS[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_SYNC_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_SYNC_STATUS(ref _MC_AXIS_SYNC_STATUS[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_SYNC_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_SYNC_STATUS(ref _MC_AXIS_SYNC_STATUS[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_SYNC_STATUS(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_CAM_SECTION(ref _MC_CAM_SECTION dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUint(ref dst.Phase, src, 1, 0 + wordOffset);
            ByteToUshort(ref dst.Curve, src, 1, 2 + wordOffset);
            ByteToDouble(ref dst.Displacement, src, 1, 4 + wordOffset);
            ByteToShort(ref dst.StartVel, src, 1, 8 + wordOffset);
            ByteToShort(ref dst.EndVel, src, 1, 9 + wordOffset);
            ByteToShort(ref dst.StartAcc, src, 1, 10 + wordOffset);
            ByteToShort(ref dst.EndAcc, src, 1, 11 + wordOffset);
        }
        private static void ByteToBase__MC_CAM_SECTION(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_CAM_SECTION elemTmp = new _MC_CAM_SECTION();
                NextIndices(dst, indices);
                ByteTo__MC_CAM_SECTION(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_CAM_SECTION_WSIZE;
            }
        }
        public static void ByteTo__MC_CAM_SECTION(ref _MC_CAM_SECTION[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_CAM_SECTION(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_CAM_SECTION(ref _MC_CAM_SECTION[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_CAM_SECTION(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_CAM_SECTION(ref _MC_CAM_SECTION[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_CAM_SECTION(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_CAM_SECTION(ref _MC_CAM_SECTION[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_CAM_SECTION(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_CAM_SECTION(ref _MC_CAM_SECTION[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_CAM_SECTION(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_CAM_SECTION(ref _MC_CAM_SECTION[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_CAM_SECTION(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_CAM_SECTION(ref _MC_CAM_SECTION[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_CAM_SECTION(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_CAM_SECTION(ref _MC_CAM_SECTION[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_CAM_SECTION(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_COMMON_CMP_CODE(ref _MC_COMMON_CMP_CODE dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUshort(ref dst.FlashRomWrite, src, 1, 0 + wordOffset);
            ByteToUshort(ref dst.SyncContactParamChg, src, 1, 1 + wordOffset);
            ByteToUshort(ref dst.Reserved, src, 6, 2 + wordOffset);
        }
        private static void ByteToBase__MC_COMMON_CMP_CODE(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_COMMON_CMP_CODE elemTmp = new _MC_COMMON_CMP_CODE();
                NextIndices(dst, indices);
                ByteTo__MC_COMMON_CMP_CODE(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_COMMON_CMP_CODE_WSIZE;
            }
        }
        public static void ByteTo__MC_COMMON_CMP_CODE(ref _MC_COMMON_CMP_CODE[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_CMP_CODE(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_CMP_CODE(ref _MC_COMMON_CMP_CODE[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_CMP_CODE(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_CMP_CODE(ref _MC_COMMON_CMP_CODE[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_CMP_CODE(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_CMP_CODE(ref _MC_COMMON_CMP_CODE[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_CMP_CODE(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_CMP_CODE(ref _MC_COMMON_CMP_CODE[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_CMP_CODE(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_CMP_CODE(ref _MC_COMMON_CMP_CODE[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_CMP_CODE(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_CMP_CODE(ref _MC_COMMON_CMP_CODE[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_CMP_CODE(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_CMP_CODE(ref _MC_COMMON_CMP_CODE[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_CMP_CODE(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_COMMON_CTRL(ref _MC_COMMON_CTRL dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToInt(ref dst.ExtRefCmdVal, src, 48, 0 + wordOffset);
        }
        private static void ByteToBase__MC_COMMON_CTRL(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_COMMON_CTRL elemTmp = new _MC_COMMON_CTRL();
                NextIndices(dst, indices);
                ByteTo__MC_COMMON_CTRL(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_COMMON_CTRL_WSIZE;
            }
        }
        public static void ByteTo__MC_COMMON_CTRL(ref _MC_COMMON_CTRL[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_CTRL(ref _MC_COMMON_CTRL[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_CTRL(ref _MC_COMMON_CTRL[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_CTRL(ref _MC_COMMON_CTRL[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_CTRL(ref _MC_COMMON_CTRL[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_CTRL(ref _MC_COMMON_CTRL[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_CTRL(ref _MC_COMMON_CTRL[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_CTRL(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_CTRL(ref _MC_COMMON_CTRL[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_CTRL(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_COMMON_PERFORMANCE(ref _MC_COMMON_PERFORMANCE dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUint(ref dst.CurrentCycleTime, src, 1, 0 + wordOffset);
            ByteToUint(ref dst.MaxCycleTime, src, 1, 2 + wordOffset);
            ByteToUshort(ref dst.CurrentLoadFactor, src, 1, 4 + wordOffset);
            ByteToUshort(ref dst.MaxLoadFactor, src, 1, 5 + wordOffset);
            ByteToUshort(ref dst.Reserved, src, 6, 6 + wordOffset);
        }
        private static void ByteToBase__MC_COMMON_PERFORMANCE(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_COMMON_PERFORMANCE elemTmp = new _MC_COMMON_PERFORMANCE();
                NextIndices(dst, indices);
                ByteTo__MC_COMMON_PERFORMANCE(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_COMMON_PERFORMANCE_WSIZE;
            }
        }
        public static void ByteTo__MC_COMMON_PERFORMANCE(ref _MC_COMMON_PERFORMANCE[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_PERFORMANCE(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_PERFORMANCE(ref _MC_COMMON_PERFORMANCE[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_PERFORMANCE(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_PERFORMANCE(ref _MC_COMMON_PERFORMANCE[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_PERFORMANCE(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_PERFORMANCE(ref _MC_COMMON_PERFORMANCE[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_PERFORMANCE(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_PERFORMANCE(ref _MC_COMMON_PERFORMANCE[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_PERFORMANCE(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_PERFORMANCE(ref _MC_COMMON_PERFORMANCE[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_PERFORMANCE(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_PERFORMANCE(ref _MC_COMMON_PERFORMANCE[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_PERFORMANCE(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_PERFORMANCE(ref _MC_COMMON_PERFORMANCE[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_PERFORMANCE(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_COMMON_STATUS_BIT(ref _MC_COMMON_STATUS_BIT dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBool(ref dst.Enable, src, 1, 0 + wordOffset, 0);
            ByteToBool(ref dst.EnableError, src, 1, 0 + wordOffset, 1);
            ByteToBool(ref dst.UnitError, src, 1, 0 + wordOffset, 3);
            ByteToBool(ref dst.AxisError, src, 1, 0 + wordOffset, 4);
            ByteToBool(ref dst.AxisWarning, src, 1, 0 + wordOffset, 5);
            ByteToBool(ref dst.TestRunning, src, 1, 0 + wordOffset, 6);
            ByteToBool(ref dst.Reserved, src, 48, 1 + wordOffset, 0);
        }
        private static void ByteToBase__MC_COMMON_STATUS_BIT(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_COMMON_STATUS_BIT elemTmp = new _MC_COMMON_STATUS_BIT();
                NextIndices(dst, indices);
                ByteTo__MC_COMMON_STATUS_BIT(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_COMMON_STATUS_BIT_WSIZE;
            }
        }
        public static void ByteTo__MC_COMMON_STATUS_BIT(ref _MC_COMMON_STATUS_BIT[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_STATUS_BIT(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_STATUS_BIT(ref _MC_COMMON_STATUS_BIT[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_STATUS_BIT(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_STATUS_BIT(ref _MC_COMMON_STATUS_BIT[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_STATUS_BIT(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_STATUS_BIT(ref _MC_COMMON_STATUS_BIT[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_STATUS_BIT(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_STATUS_BIT(ref _MC_COMMON_STATUS_BIT[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_STATUS_BIT(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_STATUS_BIT(ref _MC_COMMON_STATUS_BIT[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_STATUS_BIT(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_STATUS_BIT(ref _MC_COMMON_STATUS_BIT[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_STATUS_BIT(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_STATUS_BIT(ref _MC_COMMON_STATUS_BIT[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_STATUS_BIT(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_POINT_PARAM(ref _MC_POINT_PARAM dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUshort(ref dst.PositioningMode, src, 1, 0 + wordOffset);
            ByteToUshort(ref dst.ContinuousMode, src, 1, 1 + wordOffset);
            ByteToUshort(ref dst.NextPointNo, src, 1, 2 + wordOffset);
            ByteToUshort(ref dst.MCodeNo, src, 1, 3 + wordOffset);
            ByteToDouble(ref dst.TargetPos, src, 1, 4 + wordOffset);
            ByteToUshort(ref dst.DwellTime, src, 1, 8 + wordOffset);
            ByteToUshort(ref dst.AxisGroupNo, src, 1, 9 + wordOffset);
            ByteToDouble(ref dst.StopSensorMovement_ArcPos, src, 1, 12 + wordOffset);
            ByteToDouble(ref dst.TargetVel, src, 1, 16 + wordOffset);
            ByteToDouble(ref dst.Acceleration, src, 1, 20 + wordOffset);
            ByteToDouble(ref dst.Deceleration, src, 1, 24 + wordOffset);
            ByteToDouble(ref dst.AuxArcRadius, src, 1, 28 + wordOffset);
            ByteToDouble(ref dst.TrqLimit, src, 1, 32 + wordOffset);
            ByteToUshort(ref dst.Revolution, src, 1, 36 + wordOffset);
            ByteToUshort(ref dst.Reserved, src, 3, 37 + wordOffset);
        }
        private static void ByteToBase__MC_POINT_PARAM(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_POINT_PARAM elemTmp = new _MC_POINT_PARAM();
                NextIndices(dst, indices);
                ByteTo__MC_POINT_PARAM(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_POINT_PARAM_WSIZE;
            }
        }
        public static void ByteTo__MC_POINT_PARAM(ref _MC_POINT_PARAM[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_POINT_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_POINT_PARAM(ref _MC_POINT_PARAM[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_POINT_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_POINT_PARAM(ref _MC_POINT_PARAM[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_POINT_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_POINT_PARAM(ref _MC_POINT_PARAM[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_POINT_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_POINT_PARAM(ref _MC_POINT_PARAM[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_POINT_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_POINT_PARAM(ref _MC_POINT_PARAM[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_POINT_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_POINT_PARAM(ref _MC_POINT_PARAM[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_POINT_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_POINT_PARAM(ref _MC_POINT_PARAM[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_POINT_PARAM(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_POINT_PARAM_AXIS(ref _MC_POINT_PARAM_AXIS dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteTo__MC_POINT_PARAM(ref dst.Point, src, 50, 0 + wordOffset);
        }
        private static void ByteToBase__MC_POINT_PARAM_AXIS(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_POINT_PARAM_AXIS elemTmp = new _MC_POINT_PARAM_AXIS();
                NextIndices(dst, indices);
                ByteTo__MC_POINT_PARAM_AXIS(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_POINT_PARAM_AXIS_WSIZE;
            }
        }
        public static void ByteTo__MC_POINT_PARAM_AXIS(ref _MC_POINT_PARAM_AXIS[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_POINT_PARAM_AXIS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_POINT_PARAM_AXIS(ref _MC_POINT_PARAM_AXIS[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_POINT_PARAM_AXIS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_POINT_PARAM_AXIS(ref _MC_POINT_PARAM_AXIS[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_POINT_PARAM_AXIS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_POINT_PARAM_AXIS(ref _MC_POINT_PARAM_AXIS[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_POINT_PARAM_AXIS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_POINT_PARAM_AXIS(ref _MC_POINT_PARAM_AXIS[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_POINT_PARAM_AXIS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_POINT_PARAM_AXIS(ref _MC_POINT_PARAM_AXIS[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_POINT_PARAM_AXIS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_POINT_PARAM_AXIS(ref _MC_POINT_PARAM_AXIS[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_POINT_PARAM_AXIS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_POINT_PARAM_AXIS(ref _MC_POINT_PARAM_AXIS[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_POINT_PARAM_AXIS(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_POS_CFG(ref _MC_POS_CFG dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUshort(ref dst.CommonSetting1, src, 1, 0 + wordOffset);
            ByteToUshort(ref dst.CommonSetting2, src, 1, 1 + wordOffset);
            ByteToDouble(ref dst.OperationStartVel, src, 1, 4 + wordOffset);
            ByteToDouble(ref dst.OperationMaxVel, src, 1, 8 + wordOffset);
            ByteToDouble(ref dst.OperationAcc, src, 1, 12 + wordOffset);
            ByteToDouble(ref dst.OperationDec, src, 1, 16 + wordOffset);
            ByteToUshort(ref dst.OperationAccDecCurveRatio, src, 1, 20 + wordOffset);
            ByteToUshort(ref dst.OperationAccDecCurve, src, 1, 21 + wordOffset);
            ByteToDouble(ref dst.JogAcc, src, 1, 24 + wordOffset);
            ByteToDouble(ref dst.JogDec, src, 1, 28 + wordOffset);
            ByteToDouble(ref dst.JogStartVel, src, 1, 32 + wordOffset);
            ByteToDouble(ref dst.JogFastVel, src, 1, 36 + wordOffset);
            ByteToDouble(ref dst.JogInchingMovement, src, 1, 40 + wordOffset);
            ByteToUshort(ref dst.JogAccDecCurveRatio, src, 1, 44 + wordOffset);
            ByteToUshort(ref dst.JogAccDecCurve, src, 1, 45 + wordOffset);
            ByteToUshort(ref dst.HomingSetting, src, 1, 46 + wordOffset);
            ByteToUshort(ref dst.HomingAccDecCurveRatio, src, 1, 47 + wordOffset);
            ByteToDouble(ref dst.HomingStartVel, src, 1, 48 + wordOffset);
            ByteToDouble(ref dst.HomingCreepVel, src, 1, 52 + wordOffset);
            ByteToDouble(ref dst.HomingVel, src, 1, 56 + wordOffset);
            ByteToDouble(ref dst.HomingAcc, src, 1, 60 + wordOffset);
            ByteToDouble(ref dst.HomingDec, src, 1, 64 + wordOffset);
            ByteToDouble(ref dst.HomingPos, src, 1, 68 + wordOffset);
            ByteToDouble(ref dst.HomingBasePos, src, 1, 72 + wordOffset);
            ByteToDouble(ref dst.HomingMovementAfterDogOn, src, 1, 76 + wordOffset);
            ByteToUshort(ref dst.HomingMethod, src, 1, 80 + wordOffset);
            ByteToUshort(ref dst.HomingDwellTime, src, 1, 81 + wordOffset);
            ByteToUshort(ref dst.HomingPressTrqTime, src, 1, 83 + wordOffset);
            ByteToDouble(ref dst.HomingPressTrqThresh, src, 1, 84 + wordOffset);
            ByteToDouble(ref dst.AbsPosFollowUpCtrlVel, src, 1, 88 + wordOffset);
            ByteToDouble(ref dst.AbsPosFollowUpCtrlAcc, src, 1, 92 + wordOffset);
            ByteToDouble(ref dst.AbsPosFollowUpCtrlDec, src, 1, 96 + wordOffset);
            ByteToUint(ref dst.SyncTypeFollowUpCtrlGearNumerator, src, 1, 100 + wordOffset);
            ByteToUint(ref dst.SyncTypeFollowUpCtrlGearDenominator, src, 1, 102 + wordOffset);
            ByteToUshort(ref dst.SyncTypeFollowUpCtrlOutputFilter, src, 1, 104 + wordOffset);
            ByteToUshort(ref dst.Reserved, src, 95, 105 + wordOffset);
        }
        private static void ByteToBase__MC_POS_CFG(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_POS_CFG elemTmp = new _MC_POS_CFG();
                NextIndices(dst, indices);
                ByteTo__MC_POS_CFG(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_POS_CFG_WSIZE;
            }
        }
        public static void ByteTo__MC_POS_CFG(ref _MC_POS_CFG[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_POS_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_POS_CFG(ref _MC_POS_CFG[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_POS_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_POS_CFG(ref _MC_POS_CFG[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_POS_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_POS_CFG(ref _MC_POS_CFG[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_POS_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_POS_CFG(ref _MC_POS_CFG[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_POS_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_POS_CFG(ref _MC_POS_CFG[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_POS_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_POS_CFG(ref _MC_POS_CFG[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_POS_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_POS_CFG(ref _MC_POS_CFG[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_POS_CFG(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT(ref _MC_SYNC_CONTACT_OUTPUT dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBool(ref dst.Output, src, 16, 0 + wordOffset, 0);
        }
        private static void ByteToBase__MC_SYNC_CONTACT_OUTPUT(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_SYNC_CONTACT_OUTPUT elemTmp = new _MC_SYNC_CONTACT_OUTPUT();
                NextIndices(dst, indices);
                ByteTo__MC_SYNC_CONTACT_OUTPUT(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_SYNC_CONTACT_OUTPUT_WSIZE;
            }
        }
        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT(ref _MC_SYNC_CONTACT_OUTPUT[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_CONTACT_OUTPUT(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT(ref _MC_SYNC_CONTACT_OUTPUT[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_CONTACT_OUTPUT(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT(ref _MC_SYNC_CONTACT_OUTPUT[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_CONTACT_OUTPUT(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT(ref _MC_SYNC_CONTACT_OUTPUT[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_CONTACT_OUTPUT(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT(ref _MC_SYNC_CONTACT_OUTPUT[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_CONTACT_OUTPUT(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT(ref _MC_SYNC_CONTACT_OUTPUT[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_CONTACT_OUTPUT(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT(ref _MC_SYNC_CONTACT_OUTPUT[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_CONTACT_OUTPUT(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT(ref _MC_SYNC_CONTACT_OUTPUT[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_CONTACT_OUTPUT(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT_SUB_CFG(ref _MC_SYNC_CONTACT_OUTPUT_SUB_CFG dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToDouble(ref dst.OnVal, src, 1, 0 + wordOffset);
            ByteToDouble(ref dst.OffVal, src, 1, 4 + wordOffset);
            ByteToUshort(ref dst.OutputDst, src, 1, 8 + wordOffset);
            ByteToUshort(ref dst.Reserved, src, 3, 9 + wordOffset);
        }
        private static void ByteToBase__MC_SYNC_CONTACT_OUTPUT_SUB_CFG(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_SYNC_CONTACT_OUTPUT_SUB_CFG elemTmp = new _MC_SYNC_CONTACT_OUTPUT_SUB_CFG();
                NextIndices(dst, indices);
                ByteTo__MC_SYNC_CONTACT_OUTPUT_SUB_CFG(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_SYNC_CONTACT_OUTPUT_SUB_CFG_WSIZE;
            }
        }
        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT_SUB_CFG(ref _MC_SYNC_CONTACT_OUTPUT_SUB_CFG[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_CONTACT_OUTPUT_SUB_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT_SUB_CFG(ref _MC_SYNC_CONTACT_OUTPUT_SUB_CFG[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_CONTACT_OUTPUT_SUB_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT_SUB_CFG(ref _MC_SYNC_CONTACT_OUTPUT_SUB_CFG[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_CONTACT_OUTPUT_SUB_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT_SUB_CFG(ref _MC_SYNC_CONTACT_OUTPUT_SUB_CFG[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_CONTACT_OUTPUT_SUB_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT_SUB_CFG(ref _MC_SYNC_CONTACT_OUTPUT_SUB_CFG[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_CONTACT_OUTPUT_SUB_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT_SUB_CFG(ref _MC_SYNC_CONTACT_OUTPUT_SUB_CFG[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_CONTACT_OUTPUT_SUB_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT_SUB_CFG(ref _MC_SYNC_CONTACT_OUTPUT_SUB_CFG[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_CONTACT_OUTPUT_SUB_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT_SUB_CFG(ref _MC_SYNC_CONTACT_OUTPUT_SUB_CFG[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_CONTACT_OUTPUT_SUB_CFG(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_SYNC_EXT_INPUT_CFG(ref _MC_SYNC_EXT_INPUT_CFG dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUshort(ref dst.BaseSetting, src, 1, 0 + wordOffset);
            ByteToUint(ref dst.DevNo, src, 1, 2 + wordOffset);
            ByteToInt(ref dst.RingCounterMin, src, 1, 4 + wordOffset);
            ByteToInt(ref dst.RingCounterMax, src, 1, 6 + wordOffset);
        }
        private static void ByteToBase__MC_SYNC_EXT_INPUT_CFG(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_SYNC_EXT_INPUT_CFG elemTmp = new _MC_SYNC_EXT_INPUT_CFG();
                NextIndices(dst, indices);
                ByteTo__MC_SYNC_EXT_INPUT_CFG(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_SYNC_EXT_INPUT_CFG_WSIZE;
            }
        }
        public static void ByteTo__MC_SYNC_EXT_INPUT_CFG(ref _MC_SYNC_EXT_INPUT_CFG[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_EXT_INPUT_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_EXT_INPUT_CFG(ref _MC_SYNC_EXT_INPUT_CFG[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_EXT_INPUT_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_EXT_INPUT_CFG(ref _MC_SYNC_EXT_INPUT_CFG[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_EXT_INPUT_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_EXT_INPUT_CFG(ref _MC_SYNC_EXT_INPUT_CFG[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_EXT_INPUT_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_EXT_INPUT_CFG(ref _MC_SYNC_EXT_INPUT_CFG[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_EXT_INPUT_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_EXT_INPUT_CFG(ref _MC_SYNC_EXT_INPUT_CFG[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_EXT_INPUT_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_EXT_INPUT_CFG(ref _MC_SYNC_EXT_INPUT_CFG[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_EXT_INPUT_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_EXT_INPUT_CFG(ref _MC_SYNC_EXT_INPUT_CFG[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_EXT_INPUT_CFG(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_SYNC_PARAM(ref _MC_SYNC_PARAM dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToDouble(ref dst.InputAxisCycle, src, 1, 0 + wordOffset);
            ByteToUshort(ref dst.UnitAndPrecision, src, 1, 4 + wordOffset);
            ByteToUshort(ref dst.ClutchOffSlippingTimeAtDecStop, src, 1, 5 + wordOffset);
            ByteToUshort(ref dst.InputAxisPhaseInitMethod, src, 1, 6 + wordOffset);
            ByteToDouble(ref dst.MainAxisInitialPhase, src, 1, 8 + wordOffset);
            ByteToDouble(ref dst.MainAxisInitialPhaseAfterCompensation, src, 1, 12 + wordOffset);
            ByteToDouble(ref dst.MainClutchInputInitialPhase, src, 1, 16 + wordOffset);
            ByteToDouble(ref dst.AuxClutchInputInitialPhase, src, 1, 20 + wordOffset);
            ByteToUshort(ref dst.CamInClutchOutPhaseInitMethod, src, 1, 24 + wordOffset);
            ByteToDouble(ref dst.MainClutchOutputInitialPhase, src, 1, 28 + wordOffset);
            ByteToDouble(ref dst.AuxClutchOutputInitialPhase, src, 1, 32 + wordOffset);
            ByteToDouble(ref dst.TrqLimitClutchInputInitialPhase, src, 1, 36 + wordOffset);
            ByteToDouble(ref dst.CamInputInitialPhase, src, 1, 40 + wordOffset);
            ByteToDouble(ref dst.CamOutputBasePos, src, 1, 44 + wordOffset);
            ByteToUshort(ref dst.MainAxis1Input, src, 1, 48 + wordOffset);
            ByteToUshort(ref dst.MainAxis1CoordTrans, src, 1, 49 + wordOffset);
            ByteToUint(ref dst.MainAxis1CoordTransNumerator, src, 1, 50 + wordOffset);
            ByteToUint(ref dst.MainAxis1CoordTransDenominator, src, 1, 52 + wordOffset);
            ByteToUshort(ref dst.MainAxis2Input, src, 1, 54 + wordOffset);
            ByteToUshort(ref dst.MainAxis2CoordTrans, src, 1, 55 + wordOffset);
            ByteToUint(ref dst.MainAxis2CoordTransNumerator, src, 1, 56 + wordOffset);
            ByteToUint(ref dst.MainAxis2CoordTransDenominator, src, 1, 58 + wordOffset);
            ByteToUshort(ref dst.AuxAxisInput, src, 1, 60 + wordOffset);
            ByteToUshort(ref dst.AuxAxisCoordTrans, src, 1, 61 + wordOffset);
            ByteToUint(ref dst.AuxAxisCoordTransNumerator, src, 1, 62 + wordOffset);
            ByteToUint(ref dst.AuxAxisCoordTransDenominator, src, 1, 64 + wordOffset);
            ByteToDouble(ref dst.MainAxisPhaseCompensationCmdVal, src, 1, 68 + wordOffset);
            ByteToUshort(ref dst.MainAxisPhaseCompensationChgMethod, src, 1, 72 + wordOffset);
            ByteToUshort(ref dst.MainAxisPhaseCompensationChgTime, src, 1, 73 + wordOffset);
            ByteToDouble(ref dst.AuxAxisPhaseCompensationCmdVal, src, 1, 76 + wordOffset);
            ByteToUshort(ref dst.AuxAxisPhaseCompensationChgMethod, src, 1, 80 + wordOffset);
            ByteToUshort(ref dst.AuxAxisPhaseCompensationChgTime, src, 1, 81 + wordOffset);
            ByteToDouble(ref dst.StepAngleCompensationBaseVel, src, 1, 84 + wordOffset);
            ByteToDouble(ref dst.StepAngleCompensationBaseValue, src, 1, 88 + wordOffset);
            ByteToUshort(ref dst.StepAngleCompensationChgMethod, src, 1, 92 + wordOffset);
            ByteToUshort(ref dst.StepAngleCompensationChgTime, src, 1, 93 + wordOffset);
            ByteToInt(ref dst.VariableGearRatioNumerator, src, 1, 94 + wordOffset);
            ByteToUint(ref dst.VariableGearRatioDenominator, src, 1, 96 + wordOffset);
            ByteToUshort(ref dst.VariableGearRatioChgMethod, src, 1, 98 + wordOffset);
            ByteToUshort(ref dst.VariableGearRatioChgTime, src, 1, 99 + wordOffset);
            ByteToUshort(ref dst.MainClutchOnCondition, src, 1, 100 + wordOffset);
            ByteToUshort(ref dst.MainClutchOnEngagingMethod, src, 1, 101 + wordOffset);
            ByteToUshort(ref dst.MainClutchOnSlippingMode, src, 1, 102 + wordOffset);
            ByteToUshort(ref dst.MainClutchOnDisableMethod, src, 1, 103 + wordOffset);
            ByteToDouble(ref dst.MainClutchOnSettingVal, src, 1, 104 + wordOffset);
            ByteToDouble(ref dst.MainClutchOnDelay, src, 1, 108 + wordOffset);
            ByteToDouble(ref dst.MainClutchOnSlippage, src, 1, 112 + wordOffset);
            ByteToUshort(ref dst.MainClutchOnSlippingCurve, src, 1, 116 + wordOffset);
            ByteToUshort(ref dst.MainClutchOnSlippingTime, src, 1, 117 + wordOffset);
            ByteToUshort(ref dst.MainClutchOnFollowingTime, src, 1, 119 + wordOffset);
            ByteToDouble(ref dst.MainClutchOnFollowUpMovement, src, 1, 120 + wordOffset);
            ByteToUshort(ref dst.MainClutchOffCondition, src, 1, 124 + wordOffset);
            ByteToUshort(ref dst.MainClutchOffEngagingMethod, src, 1, 125 + wordOffset);
            ByteToUshort(ref dst.MainClutchOffSlippingMode, src, 1, 126 + wordOffset);
            ByteToUshort(ref dst.MainClutchOffDisableMethod, src, 1, 127 + wordOffset);
            ByteToDouble(ref dst.MainClutchOffSettingVal, src, 1, 128 + wordOffset);
            ByteToDouble(ref dst.MainClutchOffDelay, src, 1, 132 + wordOffset);
            ByteToDouble(ref dst.MainClutchOffSlippage, src, 1, 136 + wordOffset);
            ByteToUshort(ref dst.MainClutchOffSlippingCurve, src, 1, 140 + wordOffset);
            ByteToUshort(ref dst.MainClutchOffSlippingTime, src, 1, 141 + wordOffset);
            ByteToUshort(ref dst.AuxClutchOnCondition, src, 1, 144 + wordOffset);
            ByteToUshort(ref dst.AuxClutchOnEngagingMethod, src, 1, 145 + wordOffset);
            ByteToUshort(ref dst.AuxClutchOnSlippingMode, src, 1, 146 + wordOffset);
            ByteToUshort(ref dst.AuxClutchOnDisableMethod, src, 1, 147 + wordOffset);
            ByteToDouble(ref dst.AuxClutchOnSettingVal, src, 1, 148 + wordOffset);
            ByteToDouble(ref dst.AuxClutchOnDelay, src, 1, 152 + wordOffset);
            ByteToDouble(ref dst.AuxClutchOnSlippage, src, 1, 156 + wordOffset);
            ByteToUshort(ref dst.AuxClutchOnSlippingCurve, src, 1, 160 + wordOffset);
            ByteToUshort(ref dst.AuxClutchOnSlippingTime, src, 1, 161 + wordOffset);
            ByteToUshort(ref dst.AuxClutchOffCondition, src, 1, 164 + wordOffset);
            ByteToUshort(ref dst.AuxClutchOffEngagingMethod, src, 1, 165 + wordOffset);
            ByteToUshort(ref dst.AuxClutchOffSlippingMode, src, 1, 166 + wordOffset);
            ByteToUshort(ref dst.AuxClutchOffDisableMethod, src, 1, 167 + wordOffset);
            ByteToDouble(ref dst.AuxClutchOffSettingVal, src, 1, 168 + wordOffset);
            ByteToDouble(ref dst.AuxClutchOffDelay, src, 1, 172 + wordOffset);
            ByteToDouble(ref dst.AuxClutchOffSlippage, src, 1, 176 + wordOffset);
            ByteToUshort(ref dst.AuxClutchOffSlippingCurve, src, 1, 180 + wordOffset);
            ByteToUshort(ref dst.AuxClutchOffSlippingTime, src, 1, 181 + wordOffset);
            ByteToUshort(ref dst.CamDataNo, src, 1, 182 + wordOffset);
            ByteToUshort(ref dst.ContactOutputNo, src, 1, 183 + wordOffset);
            ByteToDouble(ref dst.CamStroke, src, 1, 184 + wordOffset);
            ByteToUshort(ref dst.SimMechanicalSyncStopMethod, src, 1, 188 + wordOffset);
            ByteToUshort(ref dst.TrqLimitClutchEngagingMethod, src, 1, 189 + wordOffset);
            ByteToUshort(ref dst.OutputFilterTimeConst, src, 1, 190 + wordOffset);
            ByteToDouble(ref dst.SimMechanicalSyncStopTrq, src, 1, 192 + wordOffset);
            ByteToDouble(ref dst.TrqLimitClutchOutputJogVel, src, 1, 196 + wordOffset);
        }
        private static void ByteToBase__MC_SYNC_PARAM(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_SYNC_PARAM elemTmp = new _MC_SYNC_PARAM();
                NextIndices(dst, indices);
                ByteTo__MC_SYNC_PARAM(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_SYNC_PARAM_WSIZE;
            }
        }
        public static void ByteTo__MC_SYNC_PARAM(ref _MC_SYNC_PARAM[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_PARAM(ref _MC_SYNC_PARAM[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_PARAM(ref _MC_SYNC_PARAM[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_PARAM(ref _MC_SYNC_PARAM[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_PARAM(ref _MC_SYNC_PARAM[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_PARAM(ref _MC_SYNC_PARAM[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_PARAM(ref _MC_SYNC_PARAM[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_PARAM(ref _MC_SYNC_PARAM[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_PARAM(dst, src, len, wordOffset);
        }

        public static void ByteTo__OPERATION_RECORDER(ref _OPERATION_RECORDER dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBool(ref dst.SaveRequest, src, 1, 0 + wordOffset, 0);
            ByteToBool(ref dst.InAction, src, 1, 0 + wordOffset, 1);
            ByteToBool(ref dst.SaveTriggerMonitor, src, 1, 0 + wordOffset, 2);
            ByteToBool(ref dst.SaveBusy, src, 1, 0 + wordOffset, 3);
            ByteToBool(ref dst.Collecting, src, 1, 0 + wordOffset, 4);
            ByteToBool(ref dst.SettingError, src, 1, 0 + wordOffset, 5);
            ByteToBool(ref dst.SaveComplete, src, 1, 0 + wordOffset, 7);
            ByteToBool(ref dst.SaveError, src, 1, 0 + wordOffset, 8);
            ByteToBool(ref dst.BufferShortage, src, 1, 0 + wordOffset, 9);
            ByteToBool(ref dst.BufferAllSaveMode, src, 1, 0 + wordOffset, 14);
            ByteToInt(ref dst.AverageSamplingPeriod, src, 1, 2 + wordOffset);
            ByteToInt(ref dst.AverageChangedDeviceNum, src, 1, 4 + wordOffset);
            ByteToInt(ref dst.MaxCollectingPeriod, src, 1, 6 + wordOffset);
            ByteToUshort(ref dst.SaveFinCode, src, 1, 20 + wordOffset);
            ByteToUshort(ref dst.SaveCounter, src, 1, 22 + wordOffset);
            ByteToUshort(ref dst.SaveProgressInfo1, src, 1, 24 + wordOffset);
            ByteToUshort(ref dst.SaveProgressInfo2, src, 1, 25 + wordOffset);
            ByteToUshort(ref dst.SaveProgress, src, 1, 26 + wordOffset);
            ByteToString(ref dst.SavePath, src, 1, 30 + wordOffset, 321);
            ByteToUshort(ref dst.Reserved, src, 9, 191 + wordOffset);
        }
        private static void ByteToBase__OPERATION_RECORDER(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _OPERATION_RECORDER elemTmp = new _OPERATION_RECORDER();
                NextIndices(dst, indices);
                ByteTo__OPERATION_RECORDER(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _OPERATION_RECORDER_WSIZE;
            }
        }
        public static void ByteTo__OPERATION_RECORDER(ref _OPERATION_RECORDER[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__OPERATION_RECORDER(dst, src, len, wordOffset);
        }
        public static void ByteTo__OPERATION_RECORDER(ref _OPERATION_RECORDER[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__OPERATION_RECORDER(dst, src, len, wordOffset);
        }
        public static void ByteTo__OPERATION_RECORDER(ref _OPERATION_RECORDER[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__OPERATION_RECORDER(dst, src, len, wordOffset);
        }
        public static void ByteTo__OPERATION_RECORDER(ref _OPERATION_RECORDER[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__OPERATION_RECORDER(dst, src, len, wordOffset);
        }
        public static void ByteTo__OPERATION_RECORDER(ref _OPERATION_RECORDER[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__OPERATION_RECORDER(dst, src, len, wordOffset);
        }
        public static void ByteTo__OPERATION_RECORDER(ref _OPERATION_RECORDER[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__OPERATION_RECORDER(dst, src, len, wordOffset);
        }
        public static void ByteTo__OPERATION_RECORDER(ref _OPERATION_RECORDER[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__OPERATION_RECORDER(dst, src, len, wordOffset);
        }
        public static void ByteTo__OPERATION_RECORDER(ref _OPERATION_RECORDER[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__OPERATION_RECORDER(dst, src, len, wordOffset);
        }

        public static void ByteTo__PROGRAM_INFO(ref _PROGRAM_INFO dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUint(ref dst.ScanTime, src, 1, 0 + wordOffset);
            ByteToUint(ref dst.EndProcTime, src, 1, 2 + wordOffset);
            ByteToUint(ref dst.MinScanTime, src, 1, 4 + wordOffset);
            ByteToUint(ref dst.MaxScanTime, src, 1, 6 + wordOffset);
            ByteToUint(ref dst.FixScanTimeSet, src, 1, 8 + wordOffset);
            ByteToUint(ref dst.EndProcTimeSet, src, 1, 10 + wordOffset);
            ByteToUint(ref dst.ExcessConstantScanTime, src, 1, 12 + wordOffset);
            ByteToUint(ref dst.ExcessEndProcTime, src, 1, 14 + wordOffset);
            ByteToUshort(ref dst.ProgramErrorDetail, src, 1, 23 + wordOffset);
            ByteToBool(ref dst.FixScanTimeEnable, src, 1, 24 + wordOffset, 3);
            ByteToBool(ref dst.FixTimeExcess, src, 1, 24 + wordOffset, 4);
            ByteToBool(ref dst.OCPDisabled, src, 1, 24 + wordOffset, 5);
            ByteToBool(ref dst.BackupBattError, src, 1, 24 + wordOffset, 6);
            ByteToBool(ref dst.ScanTimeMaxMinClear, src, 1, 24 + wordOffset, 7);
            ByteToBool(ref dst.FixEndProcTimeEnable, src, 1, 24 + wordOffset, 8);
            ByteToBool(ref dst.TimeError, src, 1, 24 + wordOffset, 11);
            ByteToBool(ref dst.ProjectPasswordAuthDisabled, src, 1, 24 + wordOffset, 14);
            ByteToUshort(ref dst.Reserved, src, 1, 25 + wordOffset);
        }
        private static void ByteToBase__PROGRAM_INFO(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _PROGRAM_INFO elemTmp = new _PROGRAM_INFO();
                NextIndices(dst, indices);
                ByteTo__PROGRAM_INFO(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _PROGRAM_INFO_WSIZE;
            }
        }
        public static void ByteTo__PROGRAM_INFO(ref _PROGRAM_INFO[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__PROGRAM_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__PROGRAM_INFO(ref _PROGRAM_INFO[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__PROGRAM_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__PROGRAM_INFO(ref _PROGRAM_INFO[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__PROGRAM_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__PROGRAM_INFO(ref _PROGRAM_INFO[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__PROGRAM_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__PROGRAM_INFO(ref _PROGRAM_INFO[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__PROGRAM_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__PROGRAM_INFO(ref _PROGRAM_INFO[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__PROGRAM_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__PROGRAM_INFO(ref _PROGRAM_INFO[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__PROGRAM_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__PROGRAM_INFO(ref _PROGRAM_INFO[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__PROGRAM_INFO(dst, src, len, wordOffset);
        }

        public static void ByteTo__PROJECT_INFO(ref _PROJECT_INFO dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToString(ref dst.ProjectName, src, 1, 0 + wordOffset, 65);
            ByteToUshort(ref dst.SensorInstExecCount, src, 1, 34 + wordOffset);
            ByteToUshort(ref dst.PrjPasswordCertFailCount, src, 1, 35 + wordOffset);
            ByteToUshort(ref dst.PrjPasswordCertFailTotal, src, 1, 36 + wordOffset);
            ByteToUshort(ref dst.CpuFuncVersion, src, 1, 38 + wordOffset);
            ByteToUshort(ref dst.ProjectVersion, src, 1, 45 + wordOffset);
        }
        private static void ByteToBase__PROJECT_INFO(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _PROJECT_INFO elemTmp = new _PROJECT_INFO();
                NextIndices(dst, indices);
                ByteTo__PROJECT_INFO(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _PROJECT_INFO_WSIZE;
            }
        }
        public static void ByteTo__PROJECT_INFO(ref _PROJECT_INFO[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__PROJECT_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__PROJECT_INFO(ref _PROJECT_INFO[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__PROJECT_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__PROJECT_INFO(ref _PROJECT_INFO[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__PROJECT_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__PROJECT_INFO(ref _PROJECT_INFO[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__PROJECT_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__PROJECT_INFO(ref _PROJECT_INFO[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__PROJECT_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__PROJECT_INFO(ref _PROJECT_INFO[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__PROJECT_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__PROJECT_INFO(ref _PROJECT_INFO[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__PROJECT_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__PROJECT_INFO(ref _PROJECT_INFO[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__PROJECT_INFO(dst, src, len, wordOffset);
        }

        public static void ByteTo__PROJECT_RECIPE_SAVE_LOAD(ref _PROJECT_RECIPE_SAVE_LOAD dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBool(ref dst.Request, src, 1, 0 + wordOffset, 0);
            ByteToBool(ref dst.Busy, src, 1, 0 + wordOffset, 1);
            ByteToBool(ref dst.Complete, src, 1, 0 + wordOffset, 2);
            ByteToBool(ref dst.Error, src, 1, 0 + wordOffset, 3);
            ByteToUshort(ref dst.DriveNumber, src, 1, 1 + wordOffset);
            ByteToUshort(ref dst.FolderNumber, src, 1, 2 + wordOffset);
            ByteToUshort(ref dst.CompleteDriveNumber, src, 1, 3 + wordOffset);
            ByteToUshort(ref dst.CompleteFolderNumber, src, 1, 4 + wordOffset);
            ByteToUshort(ref dst.FinCode, src, 1, 5 + wordOffset);
        }
        private static void ByteToBase__PROJECT_RECIPE_SAVE_LOAD(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _PROJECT_RECIPE_SAVE_LOAD elemTmp = new _PROJECT_RECIPE_SAVE_LOAD();
                NextIndices(dst, indices);
                ByteTo__PROJECT_RECIPE_SAVE_LOAD(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _PROJECT_RECIPE_SAVE_LOAD_WSIZE;
            }
        }
        public static void ByteTo__PROJECT_RECIPE_SAVE_LOAD(ref _PROJECT_RECIPE_SAVE_LOAD[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__PROJECT_RECIPE_SAVE_LOAD(dst, src, len, wordOffset);
        }
        public static void ByteTo__PROJECT_RECIPE_SAVE_LOAD(ref _PROJECT_RECIPE_SAVE_LOAD[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__PROJECT_RECIPE_SAVE_LOAD(dst, src, len, wordOffset);
        }
        public static void ByteTo__PROJECT_RECIPE_SAVE_LOAD(ref _PROJECT_RECIPE_SAVE_LOAD[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__PROJECT_RECIPE_SAVE_LOAD(dst, src, len, wordOffset);
        }
        public static void ByteTo__PROJECT_RECIPE_SAVE_LOAD(ref _PROJECT_RECIPE_SAVE_LOAD[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__PROJECT_RECIPE_SAVE_LOAD(dst, src, len, wordOffset);
        }
        public static void ByteTo__PROJECT_RECIPE_SAVE_LOAD(ref _PROJECT_RECIPE_SAVE_LOAD[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__PROJECT_RECIPE_SAVE_LOAD(dst, src, len, wordOffset);
        }
        public static void ByteTo__PROJECT_RECIPE_SAVE_LOAD(ref _PROJECT_RECIPE_SAVE_LOAD[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__PROJECT_RECIPE_SAVE_LOAD(dst, src, len, wordOffset);
        }
        public static void ByteTo__PROJECT_RECIPE_SAVE_LOAD(ref _PROJECT_RECIPE_SAVE_LOAD[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__PROJECT_RECIPE_SAVE_LOAD(dst, src, len, wordOffset);
        }
        public static void ByteTo__PROJECT_RECIPE_SAVE_LOAD(ref _PROJECT_RECIPE_SAVE_LOAD[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__PROJECT_RECIPE_SAVE_LOAD(dst, src, len, wordOffset);
        }

        public static void ByteTo__RECIPE_SAVE(ref _RECIPE_SAVE dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBool(ref dst.Request, src, 1, 0 + wordOffset, 0);
            ByteToBool(ref dst.Busy, src, 1, 0 + wordOffset, 1);
            ByteToBool(ref dst.Complete, src, 1, 0 + wordOffset, 2);
            ByteToBool(ref dst.Error, src, 1, 0 + wordOffset, 3);
            ByteToUshort(ref dst.DriveNumber, src, 1, 1 + wordOffset);
            ByteToUshort(ref dst.InputFolderNumber, src, 1, 2 + wordOffset);
            ByteToUshort(ref dst.OutputFolderNumber, src, 1, 4 + wordOffset);
            ByteToUshort(ref dst.FinCode, src, 1, 5 + wordOffset);
        }
        private static void ByteToBase__RECIPE_SAVE(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _RECIPE_SAVE elemTmp = new _RECIPE_SAVE();
                NextIndices(dst, indices);
                ByteTo__RECIPE_SAVE(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _RECIPE_SAVE_WSIZE;
            }
        }
        public static void ByteTo__RECIPE_SAVE(ref _RECIPE_SAVE[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__RECIPE_SAVE(dst, src, len, wordOffset);
        }
        public static void ByteTo__RECIPE_SAVE(ref _RECIPE_SAVE[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__RECIPE_SAVE(dst, src, len, wordOffset);
        }
        public static void ByteTo__RECIPE_SAVE(ref _RECIPE_SAVE[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__RECIPE_SAVE(dst, src, len, wordOffset);
        }
        public static void ByteTo__RECIPE_SAVE(ref _RECIPE_SAVE[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__RECIPE_SAVE(dst, src, len, wordOffset);
        }
        public static void ByteTo__RECIPE_SAVE(ref _RECIPE_SAVE[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__RECIPE_SAVE(dst, src, len, wordOffset);
        }
        public static void ByteTo__RECIPE_SAVE(ref _RECIPE_SAVE[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__RECIPE_SAVE(dst, src, len, wordOffset);
        }
        public static void ByteTo__RECIPE_SAVE(ref _RECIPE_SAVE[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__RECIPE_SAVE(dst, src, len, wordOffset);
        }
        public static void ByteTo__RECIPE_SAVE(ref _RECIPE_SAVE[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__RECIPE_SAVE(dst, src, len, wordOffset);
        }

        public static void ByteTo__SOCKET_STATUS(ref _SOCKET_STATUS dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUshort(ref dst.SocketStatus, src, 1, 0 + wordOffset);
            ByteToUshort(ref dst.TCPConnStatus, src, 1, 1 + wordOffset);
            ByteToUshort(ref dst.MyPortNo, src, 1, 2 + wordOffset);
            ByteToString(ref dst.ConnAddress, src, 1, 3 + wordOffset, 16);
            ByteToUshort(ref dst.ConnPortNo, src, 1, 11 + wordOffset);
        }
        private static void ByteToBase__SOCKET_STATUS(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _SOCKET_STATUS elemTmp = new _SOCKET_STATUS();
                NextIndices(dst, indices);
                ByteTo__SOCKET_STATUS(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _SOCKET_STATUS_WSIZE;
            }
        }
        public static void ByteTo__SOCKET_STATUS(ref _SOCKET_STATUS[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__SOCKET_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__SOCKET_STATUS(ref _SOCKET_STATUS[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__SOCKET_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__SOCKET_STATUS(ref _SOCKET_STATUS[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__SOCKET_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__SOCKET_STATUS(ref _SOCKET_STATUS[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__SOCKET_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__SOCKET_STATUS(ref _SOCKET_STATUS[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__SOCKET_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__SOCKET_STATUS(ref _SOCKET_STATUS[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__SOCKET_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__SOCKET_STATUS(ref _SOCKET_STATUS[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__SOCKET_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__SOCKET_STATUS(ref _SOCKET_STATUS[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__SOCKET_STATUS(dst, src, len, wordOffset);
        }

        public static void ByteTo__STORAGE(ref _STORAGE dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBool(ref dst.MemCardMountReq, src, 1, 0 + wordOffset, 0);
            ByteToBool(ref dst.MemCardUnmountReq, src, 1, 0 + wordOffset, 1);
            ByteToBool(ref dst.MemCardInUse, src, 1, 0 + wordOffset, 2);
            ByteToBool(ref dst.MemCardRecognized, src, 1, 0 + wordOffset, 3);
            ByteToBool(ref dst.MemCardExist, src, 1, 0 + wordOffset, 4);
            ByteToBool(ref dst.CpuMemoryMountReq, src, 1, 0 + wordOffset, 8);
            ByteToBool(ref dst.CpuMemoryUnmountReq, src, 1, 0 + wordOffset, 9);
            ByteToBool(ref dst.CpuMemoryInUse, src, 1, 0 + wordOffset, 10);
            ByteToBool(ref dst.CpuMemoryRecognized, src, 1, 0 + wordOffset, 11);
            ByteTo__AUTOLOAD_CTRL(ref dst.AutoLoad, src, 1, 3 + wordOffset);
            ByteTo__AUTOLOAD_CTRL(ref dst.RunLoad, src, 1, 10 + wordOffset);
            ByteTo__PROJECT_RECIPE_SAVE_LOAD(ref dst.ProjectSave, src, 1, 20 + wordOffset);
            ByteTo__PROJECT_RECIPE_SAVE_LOAD(ref dst.ProjectLoad, src, 1, 30 + wordOffset);
            ByteTo__RECIPE_SAVE(ref dst.RecipeSave, src, 1, 40 + wordOffset);
            ByteTo__PROJECT_RECIPE_SAVE_LOAD(ref dst.RecipeLoad, src, 1, 50 + wordOffset);
            ByteTo__CPU_MEMORY_SAVE(ref dst.CpuMemorySave, src, 1, 60 + wordOffset);
            ByteToBool(ref dst.StorageFBIsRAMMode, src, 1, 61 + wordOffset, 7);
            ByteToBool(ref dst.ProjectBackupBusy, src, 1, 61 + wordOffset, 8);
            ByteToBool(ref dst.LoggingTraceBusy, src, 1, 61 + wordOffset, 10);
            ByteToBool(ref dst.LoggingInternalBufferOverflow, src, 1, 61 + wordOffset, 11);
            ByteToUshort(ref dst.PowerOffDuringStorageAccess, src, 1, 70 + wordOffset);
            ByteToUshort(ref dst.MemoryCardRetryCount, src, 1, 71 + wordOffset);
            ByteToUshort(ref dst.MemoryCardErrorCount, src, 1, 72 + wordOffset);
            ByteToUshort(ref dst.MemoryCardResetDelay, src, 1, 74 + wordOffset);
            ByteToUint(ref dst.UsageCpuMemory, src, 1, 80 + wordOffset);
        }
        private static void ByteToBase__STORAGE(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _STORAGE elemTmp = new _STORAGE();
                NextIndices(dst, indices);
                ByteTo__STORAGE(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _STORAGE_WSIZE;
            }
        }
        public static void ByteTo__STORAGE(ref _STORAGE[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__STORAGE(dst, src, len, wordOffset);
        }
        public static void ByteTo__STORAGE(ref _STORAGE[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__STORAGE(dst, src, len, wordOffset);
        }
        public static void ByteTo__STORAGE(ref _STORAGE[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__STORAGE(dst, src, len, wordOffset);
        }
        public static void ByteTo__STORAGE(ref _STORAGE[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__STORAGE(dst, src, len, wordOffset);
        }
        public static void ByteTo__STORAGE(ref _STORAGE[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__STORAGE(dst, src, len, wordOffset);
        }
        public static void ByteTo__STORAGE(ref _STORAGE[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__STORAGE(dst, src, len, wordOffset);
        }
        public static void ByteTo__STORAGE(ref _STORAGE[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__STORAGE(dst, src, len, wordOffset);
        }
        public static void ByteTo__STORAGE(ref _STORAGE[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__STORAGE(dst, src, len, wordOffset);
        }

        public static void ByteTo__STRING_TO_VARIABLE_PARAM(ref _STRING_TO_VARIABLE_PARAM dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUshort(ref dst.Delimiter, src, 1, 0 + wordOffset);
            ByteToBool(ref dst.Hex, src, 1, 1 + wordOffset, 0);
        }
        private static void ByteToBase__STRING_TO_VARIABLE_PARAM(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _STRING_TO_VARIABLE_PARAM elemTmp = new _STRING_TO_VARIABLE_PARAM();
                NextIndices(dst, indices);
                ByteTo__STRING_TO_VARIABLE_PARAM(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _STRING_TO_VARIABLE_PARAM_WSIZE;
            }
        }
        public static void ByteTo__STRING_TO_VARIABLE_PARAM(ref _STRING_TO_VARIABLE_PARAM[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__STRING_TO_VARIABLE_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__STRING_TO_VARIABLE_PARAM(ref _STRING_TO_VARIABLE_PARAM[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__STRING_TO_VARIABLE_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__STRING_TO_VARIABLE_PARAM(ref _STRING_TO_VARIABLE_PARAM[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__STRING_TO_VARIABLE_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__STRING_TO_VARIABLE_PARAM(ref _STRING_TO_VARIABLE_PARAM[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__STRING_TO_VARIABLE_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__STRING_TO_VARIABLE_PARAM(ref _STRING_TO_VARIABLE_PARAM[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__STRING_TO_VARIABLE_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__STRING_TO_VARIABLE_PARAM(ref _STRING_TO_VARIABLE_PARAM[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__STRING_TO_VARIABLE_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__STRING_TO_VARIABLE_PARAM(ref _STRING_TO_VARIABLE_PARAM[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__STRING_TO_VARIABLE_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__STRING_TO_VARIABLE_PARAM(ref _STRING_TO_VARIABLE_PARAM[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__STRING_TO_VARIABLE_PARAM(dst, src, len, wordOffset);
        }

        public static void ByteTo__UNIT_ID_ADR(ref _UNIT_ID_ADR dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUshort(ref dst.UnitNo, src, 1, 0 + wordOffset);
            ByteToUint(ref dst.RelayAdr, src, 1, 2 + wordOffset);
            ByteToUint(ref dst.DmAdr, src, 1, 4 + wordOffset);
        }
        private static void ByteToBase__UNIT_ID_ADR(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _UNIT_ID_ADR elemTmp = new _UNIT_ID_ADR();
                NextIndices(dst, indices);
                ByteTo__UNIT_ID_ADR(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _UNIT_ID_ADR_WSIZE;
            }
        }
        public static void ByteTo__UNIT_ID_ADR(ref _UNIT_ID_ADR[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__UNIT_ID_ADR(dst, src, len, wordOffset);
        }
        public static void ByteTo__UNIT_ID_ADR(ref _UNIT_ID_ADR[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__UNIT_ID_ADR(dst, src, len, wordOffset);
        }
        public static void ByteTo__UNIT_ID_ADR(ref _UNIT_ID_ADR[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__UNIT_ID_ADR(dst, src, len, wordOffset);
        }
        public static void ByteTo__UNIT_ID_ADR(ref _UNIT_ID_ADR[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__UNIT_ID_ADR(dst, src, len, wordOffset);
        }
        public static void ByteTo__UNIT_ID_ADR(ref _UNIT_ID_ADR[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__UNIT_ID_ADR(dst, src, len, wordOffset);
        }
        public static void ByteTo__UNIT_ID_ADR(ref _UNIT_ID_ADR[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__UNIT_ID_ADR(dst, src, len, wordOffset);
        }
        public static void ByteTo__UNIT_ID_ADR(ref _UNIT_ID_ADR[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__UNIT_ID_ADR(dst, src, len, wordOffset);
        }
        public static void ByteTo__UNIT_ID_ADR(ref _UNIT_ID_ADR[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__UNIT_ID_ADR(dst, src, len, wordOffset);
        }

        public static void ByteTo__UNIT_SYNCHRONIZE(ref _UNIT_SYNCHRONIZE dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUint(ref dst.RefreshStartTimeDelay, src, 1, 0 + wordOffset);
            ByteToUint(ref dst.RefreshFinishTimeDelay, src, 1, 2 + wordOffset);
            ByteToUint(ref dst.RefreshStartTimeMaxDelay, src, 1, 4 + wordOffset);
            ByteToUint(ref dst.RefreshFinishTimeMaxDelay, src, 1, 6 + wordOffset);
            ByteToUint(ref dst.RefreshExecutionTime, src, 1, 8 + wordOffset);
            ByteToBool(ref dst.RefreshIntervalOver, src, 1, 10 + wordOffset, 0);
            ByteToUshort(ref dst.Reserved, src, 1, 11 + wordOffset);
        }
        private static void ByteToBase__UNIT_SYNCHRONIZE(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _UNIT_SYNCHRONIZE elemTmp = new _UNIT_SYNCHRONIZE();
                NextIndices(dst, indices);
                ByteTo__UNIT_SYNCHRONIZE(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _UNIT_SYNCHRONIZE_WSIZE;
            }
        }
        public static void ByteTo__UNIT_SYNCHRONIZE(ref _UNIT_SYNCHRONIZE[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__UNIT_SYNCHRONIZE(dst, src, len, wordOffset);
        }
        public static void ByteTo__UNIT_SYNCHRONIZE(ref _UNIT_SYNCHRONIZE[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__UNIT_SYNCHRONIZE(dst, src, len, wordOffset);
        }
        public static void ByteTo__UNIT_SYNCHRONIZE(ref _UNIT_SYNCHRONIZE[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__UNIT_SYNCHRONIZE(dst, src, len, wordOffset);
        }
        public static void ByteTo__UNIT_SYNCHRONIZE(ref _UNIT_SYNCHRONIZE[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__UNIT_SYNCHRONIZE(dst, src, len, wordOffset);
        }
        public static void ByteTo__UNIT_SYNCHRONIZE(ref _UNIT_SYNCHRONIZE[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__UNIT_SYNCHRONIZE(dst, src, len, wordOffset);
        }
        public static void ByteTo__UNIT_SYNCHRONIZE(ref _UNIT_SYNCHRONIZE[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__UNIT_SYNCHRONIZE(dst, src, len, wordOffset);
        }
        public static void ByteTo__UNIT_SYNCHRONIZE(ref _UNIT_SYNCHRONIZE[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__UNIT_SYNCHRONIZE(dst, src, len, wordOffset);
        }
        public static void ByteTo__UNIT_SYNCHRONIZE(ref _UNIT_SYNCHRONIZE[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__UNIT_SYNCHRONIZE(dst, src, len, wordOffset);
        }

        public static void ByteTo__VARIABLE_TO_STRING_PARAM(ref _VARIABLE_TO_STRING_PARAM dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUshort(ref dst.Delimiter, src, 1, 0 + wordOffset);
            ByteToUshort(ref dst.CrLfCount, src, 1, 1 + wordOffset);
            ByteToUshort(ref dst.EndStr, src, 1, 2 + wordOffset);
            ByteToBool(ref dst.FixedDigit, src, 1, 3 + wordOffset, 0);
            ByteToBool(ref dst.Hex, src, 1, 3 + wordOffset, 1);
        }
        private static void ByteToBase__VARIABLE_TO_STRING_PARAM(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _VARIABLE_TO_STRING_PARAM elemTmp = new _VARIABLE_TO_STRING_PARAM();
                NextIndices(dst, indices);
                ByteTo__VARIABLE_TO_STRING_PARAM(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _VARIABLE_TO_STRING_PARAM_WSIZE;
            }
        }
        public static void ByteTo__VARIABLE_TO_STRING_PARAM(ref _VARIABLE_TO_STRING_PARAM[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__VARIABLE_TO_STRING_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__VARIABLE_TO_STRING_PARAM(ref _VARIABLE_TO_STRING_PARAM[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__VARIABLE_TO_STRING_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__VARIABLE_TO_STRING_PARAM(ref _VARIABLE_TO_STRING_PARAM[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__VARIABLE_TO_STRING_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__VARIABLE_TO_STRING_PARAM(ref _VARIABLE_TO_STRING_PARAM[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__VARIABLE_TO_STRING_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__VARIABLE_TO_STRING_PARAM(ref _VARIABLE_TO_STRING_PARAM[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__VARIABLE_TO_STRING_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__VARIABLE_TO_STRING_PARAM(ref _VARIABLE_TO_STRING_PARAM[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__VARIABLE_TO_STRING_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__VARIABLE_TO_STRING_PARAM(ref _VARIABLE_TO_STRING_PARAM[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__VARIABLE_TO_STRING_PARAM(dst, src, len, wordOffset);
        }
        public static void ByteTo__VARIABLE_TO_STRING_PARAM(ref _VARIABLE_TO_STRING_PARAM[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__VARIABLE_TO_STRING_PARAM(dst, src, len, wordOffset);
        }

        public static void ByteTo__FILE_INFO(ref _FILE_INFO dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToString(ref dst.FileName, src, 1, 0 + wordOffset, 129);
            ByteTo__FILE_STATUS(ref dst.FileStatus, src, 1, 66 + wordOffset);
        }
        private static void ByteToBase__FILE_INFO(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _FILE_INFO elemTmp = new _FILE_INFO();
                NextIndices(dst, indices);
                ByteTo__FILE_INFO(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _FILE_INFO_WSIZE;
            }
        }
        public static void ByteTo__FILE_INFO(ref _FILE_INFO[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__FILE_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__FILE_INFO(ref _FILE_INFO[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__FILE_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__FILE_INFO(ref _FILE_INFO[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__FILE_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__FILE_INFO(ref _FILE_INFO[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__FILE_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__FILE_INFO(ref _FILE_INFO[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__FILE_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__FILE_INFO(ref _FILE_INFO[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__FILE_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__FILE_INFO(ref _FILE_INFO[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__FILE_INFO(dst, src, len, wordOffset);
        }
        public static void ByteTo__FILE_INFO(ref _FILE_INFO[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__FILE_INFO(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_AXIS_REF(ref _MC_AXIS_REF dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUshort(ref dst.AxisNo, src, 1, 0 + wordOffset);
            ByteTo__MC_AXIS_STATUS(ref dst.Status, src, 1, 2 + wordOffset);
            ByteTo__MC_AXIS_CMP_CODE(ref dst.CmpCode, src, 1, 114 + wordOffset);
            ByteTo__MC_AXIS_SYNC_STATUS(ref dst.SyncStatus, src, 1, 138 + wordOffset);
            ByteTo__MC_AXIS_STATUS_BIT(ref dst.StatusBit, src, 1, 218 + wordOffset);
        }
        private static void ByteToBase__MC_AXIS_REF(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_AXIS_REF elemTmp = new _MC_AXIS_REF();
                NextIndices(dst, indices);
                ByteTo__MC_AXIS_REF(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_AXIS_REF_WSIZE;
            }
        }
        public static void ByteTo__MC_AXIS_REF(ref _MC_AXIS_REF[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_REF(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_REF(ref _MC_AXIS_REF[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_REF(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_REF(ref _MC_AXIS_REF[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_REF(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_REF(ref _MC_AXIS_REF[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_REF(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_REF(ref _MC_AXIS_REF[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_REF(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_REF(ref _MC_AXIS_REF[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_REF(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_REF(ref _MC_AXIS_REF[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_REF(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_AXIS_REF(ref _MC_AXIS_REF[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_AXIS_REF(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_COMMON_CFG(ref _MC_COMMON_CFG dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUshort(ref dst.UnitCfg, src, 1, 0 + wordOffset);
            ByteTo__MC_SYNC_EXT_INPUT_CFG(ref dst.SyncExtInputCfg, src, 48, 2 + wordOffset);
        }
        private static void ByteToBase__MC_COMMON_CFG(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_COMMON_CFG elemTmp = new _MC_COMMON_CFG();
                NextIndices(dst, indices);
                ByteTo__MC_COMMON_CFG(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_COMMON_CFG_WSIZE;
            }
        }
        public static void ByteTo__MC_COMMON_CFG(ref _MC_COMMON_CFG[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_CFG(ref _MC_COMMON_CFG[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_CFG(ref _MC_COMMON_CFG[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_CFG(ref _MC_COMMON_CFG[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_CFG(ref _MC_COMMON_CFG[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_CFG(ref _MC_COMMON_CFG[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_CFG(ref _MC_COMMON_CFG[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_CFG(ref _MC_COMMON_CFG[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_CFG(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_COMMON_STATUS(ref _MC_COMMON_STATUS dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToUshort(ref dst.UnitErrorCode, src, 1, 0 + wordOffset);
            ByteToUshort(ref dst.UnitErrorDetail, src, 5, 1 + wordOffset);
            ByteTo__MC_SYNC_CONTACT_OUTPUT(ref dst.SyncContactOutput, src, 32, 6 + wordOffset);
            ByteToUshort(ref dst.Reserved, src, 2, 38 + wordOffset);
        }
        private static void ByteToBase__MC_COMMON_STATUS(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_COMMON_STATUS elemTmp = new _MC_COMMON_STATUS();
                NextIndices(dst, indices);
                ByteTo__MC_COMMON_STATUS(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_COMMON_STATUS_WSIZE;
            }
        }
        public static void ByteTo__MC_COMMON_STATUS(ref _MC_COMMON_STATUS[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_STATUS(ref _MC_COMMON_STATUS[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_STATUS(ref _MC_COMMON_STATUS[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_STATUS(ref _MC_COMMON_STATUS[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_STATUS(ref _MC_COMMON_STATUS[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_STATUS(ref _MC_COMMON_STATUS[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_STATUS(ref _MC_COMMON_STATUS[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_STATUS(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON_STATUS(ref _MC_COMMON_STATUS[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON_STATUS(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT_CFG(ref _MC_SYNC_CONTACT_OUTPUT_CFG dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteTo__MC_SYNC_CONTACT_OUTPUT_SUB_CFG(ref dst.ConfigNo, src, 32, 0 + wordOffset);
        }
        private static void ByteToBase__MC_SYNC_CONTACT_OUTPUT_CFG(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_SYNC_CONTACT_OUTPUT_CFG elemTmp = new _MC_SYNC_CONTACT_OUTPUT_CFG();
                NextIndices(dst, indices);
                ByteTo__MC_SYNC_CONTACT_OUTPUT_CFG(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_SYNC_CONTACT_OUTPUT_CFG_WSIZE;
            }
        }
        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT_CFG(ref _MC_SYNC_CONTACT_OUTPUT_CFG[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_CONTACT_OUTPUT_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT_CFG(ref _MC_SYNC_CONTACT_OUTPUT_CFG[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_CONTACT_OUTPUT_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT_CFG(ref _MC_SYNC_CONTACT_OUTPUT_CFG[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_CONTACT_OUTPUT_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT_CFG(ref _MC_SYNC_CONTACT_OUTPUT_CFG[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_CONTACT_OUTPUT_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT_CFG(ref _MC_SYNC_CONTACT_OUTPUT_CFG[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_CONTACT_OUTPUT_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT_CFG(ref _MC_SYNC_CONTACT_OUTPUT_CFG[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_CONTACT_OUTPUT_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT_CFG(ref _MC_SYNC_CONTACT_OUTPUT_CFG[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_CONTACT_OUTPUT_CFG(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_SYNC_CONTACT_OUTPUT_CFG(ref _MC_SYNC_CONTACT_OUTPUT_CFG[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_SYNC_CONTACT_OUTPUT_CFG(dst, src, len, wordOffset);
        }

        public static void ByteTo__MC_COMMON(ref _MC_COMMON dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteTo__MC_COMMON_STATUS(ref dst.Status, src, 1, 0 + wordOffset);
            ByteTo__MC_COMMON_CMP_CODE(ref dst.CmpCode, src, 1, 40 + wordOffset);
            ByteTo__MC_COMMON_PERFORMANCE(ref dst.Performance, src, 1, 48 + wordOffset);
            ByteTo__MC_COMMON_STATUS_BIT(ref dst.StatusBit, src, 1, 60 + wordOffset);
        }
        private static void ByteToBase__MC_COMMON(Array dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(dst);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                _MC_COMMON elemTmp = new _MC_COMMON();
                NextIndices(dst, indices);
                ByteTo__MC_COMMON(ref elemTmp, src, len, wordOffset);
                dst.SetValue(elemTmp, indices);
                wordOffset += _MC_COMMON_WSIZE;
            }
        }
        public static void ByteTo__MC_COMMON(ref _MC_COMMON[] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON(ref _MC_COMMON[,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON(ref _MC_COMMON[,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON(ref _MC_COMMON[,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON(ref _MC_COMMON[,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON(ref _MC_COMMON[,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON(ref _MC_COMMON[,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON(dst, src, len, wordOffset);
        }
        public static void ByteTo__MC_COMMON(ref _MC_COMMON[,,,,,,,] dst, byte[] src, int len = 1, int wordOffset = 0)
        {
            ByteToBase__MC_COMMON(dst, src, len, wordOffset);
        }

        public static void stMemArr_ToByte(ref byte[] dst, stMemArr src, int len = 1, int wordOffset = 0)
        {
            UshortToByte(ref dst, src.auSample, 100, 0 + wordOffset);
            StringToByte(ref dst, src.astrSample, 10, 100 + wordOffset, 10);
        }
        private static void stMemArr_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                stMemArr_ToByte(ref dst, ( stMemArr ) src.GetValue(indices), len, wordOffset);
                wordOffset += stMemArr_WSIZE;
            }
        }
        public static void stMemArr_ToByte(ref byte[] dst, stMemArr[] src, int len = 1, int wordOffset = 0)
        {
            stMemArr_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void stMemArr_ToByte(ref byte[] dst, stMemArr[,] src, int len = 1, int wordOffset = 0)
        {
            stMemArr_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void stMemArr_ToByte(ref byte[] dst, stMemArr[,,] src, int len = 1, int wordOffset = 0)
        {
            stMemArr_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void stMemArr_ToByte(ref byte[] dst, stMemArr[,,,] src, int len = 1, int wordOffset = 0)
        {
            stMemArr_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void stMemArr_ToByte(ref byte[] dst, stMemArr[,,,,] src, int len = 1, int wordOffset = 0)
        {
            stMemArr_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void stMemArr_ToByte(ref byte[] dst, stMemArr[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            stMemArr_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void stMemArr_ToByte(ref byte[] dst, stMemArr[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            stMemArr_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void stMemArr_ToByte(ref byte[] dst, stMemArr[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            stMemArr_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void stNode_ToByte(ref byte[] dst, stNode src, int len = 1, int wordOffset = 0)
        {
            BoolToByte(ref dst, src.xMember, 1, 0 + wordOffset, 0);
            BoolToByte(ref dst, src.xMember2, 1, 0 + wordOffset, 1);
            UshortToByte(ref dst, src.uMember, 1, 1 + wordOffset);
            ShortToByte(ref dst, src.iMember, 1, 2 + wordOffset);
            UintToByte(ref dst, src.duMember, 1, 4 + wordOffset);
            IntToByte(ref dst, src.diMember, 1, 6 + wordOffset);
            FloatToByte(ref dst, src.fMember, 1, 8 + wordOffset);
            DoubleToByte(ref dst, src.dfMember, 1, 10 + wordOffset);
            StringToByte(ref dst, src.strMember, 1, 14 + wordOffset, 16);
        }
        private static void stNode_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                stNode_ToByte(ref dst, ( stNode ) src.GetValue(indices), len, wordOffset);
                wordOffset += stNode_WSIZE;
            }
        }
        public static void stNode_ToByte(ref byte[] dst, stNode[] src, int len = 1, int wordOffset = 0)
        {
            stNode_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void stNode_ToByte(ref byte[] dst, stNode[,] src, int len = 1, int wordOffset = 0)
        {
            stNode_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void stNode_ToByte(ref byte[] dst, stNode[,,] src, int len = 1, int wordOffset = 0)
        {
            stNode_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void stNode_ToByte(ref byte[] dst, stNode[,,,] src, int len = 1, int wordOffset = 0)
        {
            stNode_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void stNode_ToByte(ref byte[] dst, stNode[,,,,] src, int len = 1, int wordOffset = 0)
        {
            stNode_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void stNode_ToByte(ref byte[] dst, stNode[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            stNode_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void stNode_ToByte(ref byte[] dst, stNode[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            stNode_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void stNode_ToByte(ref byte[] dst, stNode[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            stNode_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void stParent_ToByte(ref byte[] dst, stParent src, int len = 1, int wordOffset = 0)
        {
            BoolToByte(ref dst, src.xReq, 1, 0 + wordOffset, 0);
            BoolToByte(ref dst, src.xCmp, 1, 0 + wordOffset, 1);
            BoolToByte(ref dst, src.xErr, 1, 0 + wordOffset, 2);
            UshortToByte(ref dst, src.uErrCode, 1, 1 + wordOffset);
            stNode_ToByte(ref dst, src.stNode_Member, 1, 2 + wordOffset);
            stNode_ToByte(ref dst, src.astNode, 10, 24 + wordOffset);
        }
        private static void stParent_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                stParent_ToByte(ref dst, ( stParent ) src.GetValue(indices), len, wordOffset);
                wordOffset += stParent_WSIZE;
            }
        }
        public static void stParent_ToByte(ref byte[] dst, stParent[] src, int len = 1, int wordOffset = 0)
        {
            stParent_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void stParent_ToByte(ref byte[] dst, stParent[,] src, int len = 1, int wordOffset = 0)
        {
            stParent_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void stParent_ToByte(ref byte[] dst, stParent[,,] src, int len = 1, int wordOffset = 0)
        {
            stParent_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void stParent_ToByte(ref byte[] dst, stParent[,,,] src, int len = 1, int wordOffset = 0)
        {
            stParent_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void stParent_ToByte(ref byte[] dst, stParent[,,,,] src, int len = 1, int wordOffset = 0)
        {
            stParent_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void stParent_ToByte(ref byte[] dst, stParent[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            stParent_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void stParent_ToByte(ref byte[] dst, stParent[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            stParent_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void stParent_ToByte(ref byte[] dst, stParent[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            stParent_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _ACCESS_WINDOW_ToByte(ref byte[] dst, _ACCESS_WINDOW src, int len = 1, int wordOffset = 0)
        {
            BoolToByte(ref dst, src.UpKeyPressed, 1, 0 + wordOffset, 0);
            BoolToByte(ref dst, src.DownKeyPressed, 1, 0 + wordOffset, 1);
            BoolToByte(ref dst, src.LeftKeyPressed, 1, 0 + wordOffset, 2);
            BoolToByte(ref dst, src.RightKeyPressed, 1, 0 + wordOffset, 3);
            BoolToByte(ref dst, src.MenuKeyPressed, 1, 0 + wordOffset, 4);
            BoolToByte(ref dst, src.EnterKeyPressed, 1, 0 + wordOffset, 5);
            BoolToByte(ref dst, src.UserMessageDisplayed, 1, 0 + wordOffset, 15);
            BoolToByte(ref dst, src.BlinkLine, 4, 1 + wordOffset, 0);
            BoolToByte(ref dst, src.DisplayUserMessage, 63, 2 + wordOffset, 1);
            UshortToByte(ref dst, src.UserMessageDisplayID, 1, 10 + wordOffset);
            UshortToByte(ref dst, src.InitialDispLangSetting, 1, 11 + wordOffset);
            UshortToByte(ref dst, src.InitialCommentNumberSetting, 1, 12 + wordOffset);
            UshortToByte(ref dst, src.WindowOperationDisable, 1, 13 + wordOffset);
            UshortToByte(ref dst, src.InitScreenSetValid, 1, 14 + wordOffset);
            UshortToByte(ref dst, src.InitScreenSetDeviceType, 1, 15 + wordOffset);
            UintToByte(ref dst, src.InitScreenSetScreenID, 1, 16 + wordOffset);
            UintToByte(ref dst, src.InitScreenSetDeviceNumber, 1, 18 + wordOffset);
            UshortToByte(ref dst, src.InitScreenSetDisplayFormat, 1, 20 + wordOffset);
            UshortToByte(ref dst, src.InitScreenSetDeviceDisplay, 1, 21 + wordOffset);
            UshortToByte(ref dst, src.InitScreenSetKeyLockStatus, 1, 22 + wordOffset);
            UshortToByte(ref dst, src.Reserved, 1, 23 + wordOffset);
        }
        private static void _ACCESS_WINDOW_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _ACCESS_WINDOW_ToByte(ref dst, ( _ACCESS_WINDOW ) src.GetValue(indices), len, wordOffset);
                wordOffset += _ACCESS_WINDOW_WSIZE;
            }
        }
        public static void _ACCESS_WINDOW_ToByte(ref byte[] dst, _ACCESS_WINDOW[] src, int len = 1, int wordOffset = 0)
        {
            _ACCESS_WINDOW_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _ACCESS_WINDOW_ToByte(ref byte[] dst, _ACCESS_WINDOW[,] src, int len = 1, int wordOffset = 0)
        {
            _ACCESS_WINDOW_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _ACCESS_WINDOW_ToByte(ref byte[] dst, _ACCESS_WINDOW[,,] src, int len = 1, int wordOffset = 0)
        {
            _ACCESS_WINDOW_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _ACCESS_WINDOW_ToByte(ref byte[] dst, _ACCESS_WINDOW[,,,] src, int len = 1, int wordOffset = 0)
        {
            _ACCESS_WINDOW_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _ACCESS_WINDOW_ToByte(ref byte[] dst, _ACCESS_WINDOW[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _ACCESS_WINDOW_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _ACCESS_WINDOW_ToByte(ref byte[] dst, _ACCESS_WINDOW[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _ACCESS_WINDOW_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _ACCESS_WINDOW_ToByte(ref byte[] dst, _ACCESS_WINDOW[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _ACCESS_WINDOW_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _ACCESS_WINDOW_ToByte(ref byte[] dst, _ACCESS_WINDOW[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _ACCESS_WINDOW_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _AUTOLOAD_CTRL_ToByte(ref byte[] dst, _AUTOLOAD_CTRL src, int len = 1, int wordOffset = 0)
        {
            UshortToByte(ref dst, src.FolderNumber, 1, 1 + wordOffset);
            UshortToByte(ref dst, src.CompleteFolderNumber, 1, 3 + wordOffset);
            UshortToByte(ref dst, src.FinCode, 1, 4 + wordOffset);
        }
        private static void _AUTOLOAD_CTRL_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _AUTOLOAD_CTRL_ToByte(ref dst, ( _AUTOLOAD_CTRL ) src.GetValue(indices), len, wordOffset);
                wordOffset += _AUTOLOAD_CTRL_WSIZE;
            }
        }
        public static void _AUTOLOAD_CTRL_ToByte(ref byte[] dst, _AUTOLOAD_CTRL[] src, int len = 1, int wordOffset = 0)
        {
            _AUTOLOAD_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _AUTOLOAD_CTRL_ToByte(ref byte[] dst, _AUTOLOAD_CTRL[,] src, int len = 1, int wordOffset = 0)
        {
            _AUTOLOAD_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _AUTOLOAD_CTRL_ToByte(ref byte[] dst, _AUTOLOAD_CTRL[,,] src, int len = 1, int wordOffset = 0)
        {
            _AUTOLOAD_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _AUTOLOAD_CTRL_ToByte(ref byte[] dst, _AUTOLOAD_CTRL[,,,] src, int len = 1, int wordOffset = 0)
        {
            _AUTOLOAD_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _AUTOLOAD_CTRL_ToByte(ref byte[] dst, _AUTOLOAD_CTRL[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _AUTOLOAD_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _AUTOLOAD_CTRL_ToByte(ref byte[] dst, _AUTOLOAD_CTRL[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _AUTOLOAD_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _AUTOLOAD_CTRL_ToByte(ref byte[] dst, _AUTOLOAD_CTRL[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _AUTOLOAD_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _AUTOLOAD_CTRL_ToByte(ref byte[] dst, _AUTOLOAD_CTRL[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _AUTOLOAD_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _CPU_MEMORY_SAVE_ToByte(ref byte[] dst, _CPU_MEMORY_SAVE src, int len = 1, int wordOffset = 0)
        {
            BoolToByte(ref dst, src.Request, 1, 0 + wordOffset, 0);
            BoolToByte(ref dst, src.Busy, 1, 0 + wordOffset, 1);
            BoolToByte(ref dst, src.Complete, 1, 0 + wordOffset, 2);
            BoolToByte(ref dst, src.Error, 1, 0 + wordOffset, 3);
        }
        private static void _CPU_MEMORY_SAVE_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _CPU_MEMORY_SAVE_ToByte(ref dst, ( _CPU_MEMORY_SAVE ) src.GetValue(indices), len, wordOffset);
                wordOffset += _CPU_MEMORY_SAVE_WSIZE;
            }
        }
        public static void _CPU_MEMORY_SAVE_ToByte(ref byte[] dst, _CPU_MEMORY_SAVE[] src, int len = 1, int wordOffset = 0)
        {
            _CPU_MEMORY_SAVE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _CPU_MEMORY_SAVE_ToByte(ref byte[] dst, _CPU_MEMORY_SAVE[,] src, int len = 1, int wordOffset = 0)
        {
            _CPU_MEMORY_SAVE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _CPU_MEMORY_SAVE_ToByte(ref byte[] dst, _CPU_MEMORY_SAVE[,,] src, int len = 1, int wordOffset = 0)
        {
            _CPU_MEMORY_SAVE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _CPU_MEMORY_SAVE_ToByte(ref byte[] dst, _CPU_MEMORY_SAVE[,,,] src, int len = 1, int wordOffset = 0)
        {
            _CPU_MEMORY_SAVE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _CPU_MEMORY_SAVE_ToByte(ref byte[] dst, _CPU_MEMORY_SAVE[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _CPU_MEMORY_SAVE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _CPU_MEMORY_SAVE_ToByte(ref byte[] dst, _CPU_MEMORY_SAVE[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _CPU_MEMORY_SAVE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _CPU_MEMORY_SAVE_ToByte(ref byte[] dst, _CPU_MEMORY_SAVE[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _CPU_MEMORY_SAVE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _CPU_MEMORY_SAVE_ToByte(ref byte[] dst, _CPU_MEMORY_SAVE[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _CPU_MEMORY_SAVE_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _DEV_INFO_ToByte(ref byte[] dst, _DEV_INFO src, int len = 1, int wordOffset = 0)
        {
            UshortToByte(ref dst, src.DevType, 1, 0 + wordOffset);
            UshortToByte(ref dst, src.BitOffset, 1, 1 + wordOffset);
            UintToByte(ref dst, src.DevNo, 1, 2 + wordOffset);
        }
        private static void _DEV_INFO_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _DEV_INFO_ToByte(ref dst, ( _DEV_INFO ) src.GetValue(indices), len, wordOffset);
                wordOffset += _DEV_INFO_WSIZE;
            }
        }
        public static void _DEV_INFO_ToByte(ref byte[] dst, _DEV_INFO[] src, int len = 1, int wordOffset = 0)
        {
            _DEV_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _DEV_INFO_ToByte(ref byte[] dst, _DEV_INFO[,] src, int len = 1, int wordOffset = 0)
        {
            _DEV_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _DEV_INFO_ToByte(ref byte[] dst, _DEV_INFO[,,] src, int len = 1, int wordOffset = 0)
        {
            _DEV_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _DEV_INFO_ToByte(ref byte[] dst, _DEV_INFO[,,,] src, int len = 1, int wordOffset = 0)
        {
            _DEV_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _DEV_INFO_ToByte(ref byte[] dst, _DEV_INFO[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _DEV_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _DEV_INFO_ToByte(ref byte[] dst, _DEV_INFO[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _DEV_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _DEV_INFO_ToByte(ref byte[] dst, _DEV_INFO[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _DEV_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _DEV_INFO_ToByte(ref byte[] dst, _DEV_INFO[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _DEV_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _EC_MASTER_ToByte(ref byte[] dst, _EC_MASTER src, int len = 1, int wordOffset = 0)
        {
            BoolToByte(ref dst, src.MasterError, 1, 0 + wordOffset, 0);
            BoolToByte(ref dst, src.PDOActive, 1, 0 + wordOffset, 1);
            BoolToByte(ref dst, src.PDOInactive, 1, 0 + wordOffset, 2);
            BoolToByte(ref dst, src.PDOCommError, 1, 0 + wordOffset, 3);
            BoolToByte(ref dst, src.RingError, 1, 0 + wordOffset, 4);
            BoolToByte(ref dst, src.InDataInvalid, 1, 0 + wordOffset, 5);
            BoolToByte(ref dst, src.PDOParticipationTbl, 512, 1 + wordOffset, 0);
            BoolToByte(ref dst, src.PDOActiveTbl, 512, 33 + wordOffset, 0);
            BoolToByte(ref dst, src.PDOCommErrorTbl, 512, 65 + wordOffset, 0);
            BoolToByte(ref dst, src.SDOActiveTbl, 512, 97 + wordOffset, 0);
            BoolToByte(ref dst, src.RegTbl, 512, 129 + wordOffset, 0);
            BoolToByte(ref dst, src.ReserveTbl, 512, 161 + wordOffset, 0);
            BoolToByte(ref dst, src.PDOStopReqTbl, 512, 193 + wordOffset, 0);
            BoolToByte(ref dst, src.RingErrorTbl, 512, 225 + wordOffset, 0);
            UshortToByte(ref dst, src.EcStateTbl, 512, 257 + wordOffset);
            UshortToByte(ref dst, src.MasterErrorCode, 1, 769 + wordOffset);
            UshortToByte(ref dst, src.MasterErrorDetail1, 1, 770 + wordOffset);
            UshortToByte(ref dst, src.MasterErrorDetail2, 1, 771 + wordOffset);
        }
        private static void _EC_MASTER_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _EC_MASTER_ToByte(ref dst, ( _EC_MASTER ) src.GetValue(indices), len, wordOffset);
                wordOffset += _EC_MASTER_WSIZE;
            }
        }
        public static void _EC_MASTER_ToByte(ref byte[] dst, _EC_MASTER[] src, int len = 1, int wordOffset = 0)
        {
            _EC_MASTER_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _EC_MASTER_ToByte(ref byte[] dst, _EC_MASTER[,] src, int len = 1, int wordOffset = 0)
        {
            _EC_MASTER_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _EC_MASTER_ToByte(ref byte[] dst, _EC_MASTER[,,] src, int len = 1, int wordOffset = 0)
        {
            _EC_MASTER_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _EC_MASTER_ToByte(ref byte[] dst, _EC_MASTER[,,,] src, int len = 1, int wordOffset = 0)
        {
            _EC_MASTER_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _EC_MASTER_ToByte(ref byte[] dst, _EC_MASTER[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _EC_MASTER_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _EC_MASTER_ToByte(ref byte[] dst, _EC_MASTER[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _EC_MASTER_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _EC_MASTER_ToByte(ref byte[] dst, _EC_MASTER[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _EC_MASTER_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _EC_MASTER_ToByte(ref byte[] dst, _EC_MASTER[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _EC_MASTER_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _EC_NODE_ToByte(ref byte[] dst, _EC_NODE src, int len = 1, int wordOffset = 0)
        {
            UintToByte(ref dst, src.VenderID, 1, 0 + wordOffset);
            UintToByte(ref dst, src.ProductCode, 1, 2 + wordOffset);
            UintToByte(ref dst, src.RevisionNo, 1, 4 + wordOffset);
            UintToByte(ref dst, src.SerialNo, 1, 6 + wordOffset);
            UshortToByte(ref dst, src.StationAlias, 1, 8 + wordOffset);
            UshortToByte(ref dst, src.ConnectNodeNo, 4, 10 + wordOffset);
            UshortToByte(ref dst, src.RxErrorCount, 4, 14 + wordOffset);
            UshortToByte(ref dst, src.EmgMsgErrorCode, 1, 18 + wordOffset);
            UshortToByte(ref dst, src.EmgMsgErrorReg, 1, 19 + wordOffset);
            UshortToByte(ref dst, src.EmgMsgData0_1, 1, 20 + wordOffset);
            UshortToByte(ref dst, src.EmgMsgData2_3, 1, 21 + wordOffset);
            UshortToByte(ref dst, src.EmgMsgData4, 1, 22 + wordOffset);
            UshortToByte(ref dst, src.NodeErrorCode, 1, 23 + wordOffset);
            UshortToByte(ref dst, src.NodeErrorDetail1, 1, 24 + wordOffset);
            UshortToByte(ref dst, src.NodeErrorDetail2, 1, 25 + wordOffset);
            UshortToByte(ref dst, src.NodeWarning, 1, 26 + wordOffset);
            BoolToByte(ref dst, src.NodeError, 1, 27 + wordOffset, 0);
        }
        private static void _EC_NODE_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _EC_NODE_ToByte(ref dst, ( _EC_NODE ) src.GetValue(indices), len, wordOffset);
                wordOffset += _EC_NODE_WSIZE;
            }
        }
        public static void _EC_NODE_ToByte(ref byte[] dst, _EC_NODE[] src, int len = 1, int wordOffset = 0)
        {
            _EC_NODE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _EC_NODE_ToByte(ref byte[] dst, _EC_NODE[,] src, int len = 1, int wordOffset = 0)
        {
            _EC_NODE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _EC_NODE_ToByte(ref byte[] dst, _EC_NODE[,,] src, int len = 1, int wordOffset = 0)
        {
            _EC_NODE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _EC_NODE_ToByte(ref byte[] dst, _EC_NODE[,,,] src, int len = 1, int wordOffset = 0)
        {
            _EC_NODE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _EC_NODE_ToByte(ref byte[] dst, _EC_NODE[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _EC_NODE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _EC_NODE_ToByte(ref byte[] dst, _EC_NODE[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _EC_NODE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _EC_NODE_ToByte(ref byte[] dst, _EC_NODE[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _EC_NODE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _EC_NODE_ToByte(ref byte[] dst, _EC_NODE[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _EC_NODE_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _ERROR_CTRL_ToByte(ref byte[] dst, _ERROR_CTRL src, int len = 1, int wordOffset = 0)
        {
            BoolToByte(ref dst, src.Error, 1, 0 + wordOffset, 5);
            BoolToByte(ref dst, src.Warning, 1, 0 + wordOffset, 6);
            BoolToByte(ref dst, src.ClearCurrentError, 1, 0 + wordOffset, 9);
            BoolToByte(ref dst, src.ClearHistory, 1, 0 + wordOffset, 10);
        }
        private static void _ERROR_CTRL_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _ERROR_CTRL_ToByte(ref dst, ( _ERROR_CTRL ) src.GetValue(indices), len, wordOffset);
                wordOffset += _ERROR_CTRL_WSIZE;
            }
        }
        public static void _ERROR_CTRL_ToByte(ref byte[] dst, _ERROR_CTRL[] src, int len = 1, int wordOffset = 0)
        {
            _ERROR_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _ERROR_CTRL_ToByte(ref byte[] dst, _ERROR_CTRL[,] src, int len = 1, int wordOffset = 0)
        {
            _ERROR_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _ERROR_CTRL_ToByte(ref byte[] dst, _ERROR_CTRL[,,] src, int len = 1, int wordOffset = 0)
        {
            _ERROR_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _ERROR_CTRL_ToByte(ref byte[] dst, _ERROR_CTRL[,,,] src, int len = 1, int wordOffset = 0)
        {
            _ERROR_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _ERROR_CTRL_ToByte(ref byte[] dst, _ERROR_CTRL[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _ERROR_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _ERROR_CTRL_ToByte(ref byte[] dst, _ERROR_CTRL[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _ERROR_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _ERROR_CTRL_ToByte(ref byte[] dst, _ERROR_CTRL[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _ERROR_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _ERROR_CTRL_ToByte(ref byte[] dst, _ERROR_CTRL[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _ERROR_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _ERROR_DETAIL_ToByte(ref byte[] dst, _ERROR_DETAIL src, int len = 1, int wordOffset = 0)
        {
            UshortToByte(ref dst, src.YearMonth, 1, 0 + wordOffset);
            UshortToByte(ref dst, src.Day, 1, 1 + wordOffset);
            UshortToByte(ref dst, src.Hour, 1, 2 + wordOffset);
            UshortToByte(ref dst, src.Minute, 1, 3 + wordOffset);
            UshortToByte(ref dst, src.Second, 1, 4 + wordOffset);
            UshortToByte(ref dst, src.ErrorNumber, 1, 5 + wordOffset);
            UshortToByte(ref dst, src.ValidCount, 1, 6 + wordOffset);
            UshortToByte(ref dst, src.Detail, 20, 7 + wordOffset);
        }
        private static void _ERROR_DETAIL_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _ERROR_DETAIL_ToByte(ref dst, ( _ERROR_DETAIL ) src.GetValue(indices), len, wordOffset);
                wordOffset += _ERROR_DETAIL_WSIZE;
            }
        }
        public static void _ERROR_DETAIL_ToByte(ref byte[] dst, _ERROR_DETAIL[] src, int len = 1, int wordOffset = 0)
        {
            _ERROR_DETAIL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _ERROR_DETAIL_ToByte(ref byte[] dst, _ERROR_DETAIL[,] src, int len = 1, int wordOffset = 0)
        {
            _ERROR_DETAIL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _ERROR_DETAIL_ToByte(ref byte[] dst, _ERROR_DETAIL[,,] src, int len = 1, int wordOffset = 0)
        {
            _ERROR_DETAIL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _ERROR_DETAIL_ToByte(ref byte[] dst, _ERROR_DETAIL[,,,] src, int len = 1, int wordOffset = 0)
        {
            _ERROR_DETAIL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _ERROR_DETAIL_ToByte(ref byte[] dst, _ERROR_DETAIL[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _ERROR_DETAIL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _ERROR_DETAIL_ToByte(ref byte[] dst, _ERROR_DETAIL[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _ERROR_DETAIL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _ERROR_DETAIL_ToByte(ref byte[] dst, _ERROR_DETAIL[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _ERROR_DETAIL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _ERROR_DETAIL_ToByte(ref byte[] dst, _ERROR_DETAIL[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _ERROR_DETAIL_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _EXPANSION_UNIT_ToByte(ref byte[] dst, _EXPANSION_UNIT src, int len = 1, int wordOffset = 0)
        {
            BoolToByte(ref dst, src.Connected, 49, 0 + wordOffset, 0);
            BoolToByte(ref dst, src.LoadOption, 49, 4 + wordOffset, 0);
            UshortToByte(ref dst, src.UnitNumber, 1, 75 + wordOffset);
        }
        private static void _EXPANSION_UNIT_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _EXPANSION_UNIT_ToByte(ref dst, ( _EXPANSION_UNIT ) src.GetValue(indices), len, wordOffset);
                wordOffset += _EXPANSION_UNIT_WSIZE;
            }
        }
        public static void _EXPANSION_UNIT_ToByte(ref byte[] dst, _EXPANSION_UNIT[] src, int len = 1, int wordOffset = 0)
        {
            _EXPANSION_UNIT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _EXPANSION_UNIT_ToByte(ref byte[] dst, _EXPANSION_UNIT[,] src, int len = 1, int wordOffset = 0)
        {
            _EXPANSION_UNIT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _EXPANSION_UNIT_ToByte(ref byte[] dst, _EXPANSION_UNIT[,,] src, int len = 1, int wordOffset = 0)
        {
            _EXPANSION_UNIT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _EXPANSION_UNIT_ToByte(ref byte[] dst, _EXPANSION_UNIT[,,,] src, int len = 1, int wordOffset = 0)
        {
            _EXPANSION_UNIT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _EXPANSION_UNIT_ToByte(ref byte[] dst, _EXPANSION_UNIT[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _EXPANSION_UNIT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _EXPANSION_UNIT_ToByte(ref byte[] dst, _EXPANSION_UNIT[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _EXPANSION_UNIT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _EXPANSION_UNIT_ToByte(ref byte[] dst, _EXPANSION_UNIT[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _EXPANSION_UNIT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _EXPANSION_UNIT_ToByte(ref byte[] dst, _EXPANSION_UNIT[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _EXPANSION_UNIT_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _FILE_STATUS_ToByte(ref byte[] dst, _FILE_STATUS src, int len = 1, int wordOffset = 0)
        {
            UshortToByte(ref dst, src.ModifiedDate, 6, 0 + wordOffset);
            UintToByte(ref dst, src.FileSize, 1, 6 + wordOffset);
            BoolToByte(ref dst, src.ReadOnly, 1, 8 + wordOffset, 0);
            BoolToByte(ref dst, src.HiddenFile, 1, 8 + wordOffset, 1);
            BoolToByte(ref dst, src.SystemFile, 1, 8 + wordOffset, 2);
            BoolToByte(ref dst, src.VolumeLabel, 1, 8 + wordOffset, 3);
            BoolToByte(ref dst, src.Folder, 1, 8 + wordOffset, 4);
            BoolToByte(ref dst, src.Archive, 1, 8 + wordOffset, 5);
            UshortToByte(ref dst, src.Reserved, 1, 9 + wordOffset);
        }
        private static void _FILE_STATUS_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _FILE_STATUS_ToByte(ref dst, ( _FILE_STATUS ) src.GetValue(indices), len, wordOffset);
                wordOffset += _FILE_STATUS_WSIZE;
            }
        }
        public static void _FILE_STATUS_ToByte(ref byte[] dst, _FILE_STATUS[] src, int len = 1, int wordOffset = 0)
        {
            _FILE_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _FILE_STATUS_ToByte(ref byte[] dst, _FILE_STATUS[,] src, int len = 1, int wordOffset = 0)
        {
            _FILE_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _FILE_STATUS_ToByte(ref byte[] dst, _FILE_STATUS[,,] src, int len = 1, int wordOffset = 0)
        {
            _FILE_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _FILE_STATUS_ToByte(ref byte[] dst, _FILE_STATUS[,,,] src, int len = 1, int wordOffset = 0)
        {
            _FILE_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _FILE_STATUS_ToByte(ref byte[] dst, _FILE_STATUS[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _FILE_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _FILE_STATUS_ToByte(ref byte[] dst, _FILE_STATUS[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _FILE_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _FILE_STATUS_ToByte(ref byte[] dst, _FILE_STATUS[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _FILE_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _FILE_STATUS_ToByte(ref byte[] dst, _FILE_STATUS[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _FILE_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _LOGGING_TRACE_ToByte(ref byte[] dst, _LOGGING_TRACE src, int len = 1, int wordOffset = 0)
        {
            BoolToByte(ref dst, src.ExecEnable, 1, 0 + wordOffset, 0);
            BoolToByte(ref dst, src.InOperation, 1, 0 + wordOffset, 1);
            BoolToByte(ref dst, src.FileWriteEnd, 1, 0 + wordOffset, 2);
            BoolToByte(ref dst, src.BufferHalfAlm, 1, 0 + wordOffset, 3);
            BoolToByte(ref dst, src.BufferOverflow, 1, 0 + wordOffset, 4);
            BoolToByte(ref dst, src.WriteDuringRun, 1, 0 + wordOffset, 5);
            BoolToByte(ref dst, src.LoggingTraceError, 1, 0 + wordOffset, 8);
            BoolToByte(ref dst, src.NoMemoryCapacity, 1, 0 + wordOffset, 9);
            BoolToByte(ref dst, src.DeviceTriggerSetError, 1, 0 + wordOffset, 10);
            BoolToByte(ref dst, src.FileSaveTriggerMonitor, 1, 0 + wordOffset, 11);
            BoolToByte(ref dst, src.DataAcquireComplete, 1, 0 + wordOffset, 12);
            UshortToByte(ref dst, src.MinBufferSpace, 1, 1 + wordOffset);
            UshortToByte(ref dst, src.LoopBufferSpace, 1, 2 + wordOffset);
            UshortToByte(ref dst, src.FileSavingCounter, 1, 3 + wordOffset);
            UshortToByte(ref dst, src.Reserved, 6, 4 + wordOffset);
        }
        private static void _LOGGING_TRACE_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _LOGGING_TRACE_ToByte(ref dst, ( _LOGGING_TRACE ) src.GetValue(indices), len, wordOffset);
                wordOffset += _LOGGING_TRACE_WSIZE;
            }
        }
        public static void _LOGGING_TRACE_ToByte(ref byte[] dst, _LOGGING_TRACE[] src, int len = 1, int wordOffset = 0)
        {
            _LOGGING_TRACE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _LOGGING_TRACE_ToByte(ref byte[] dst, _LOGGING_TRACE[,] src, int len = 1, int wordOffset = 0)
        {
            _LOGGING_TRACE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _LOGGING_TRACE_ToByte(ref byte[] dst, _LOGGING_TRACE[,,] src, int len = 1, int wordOffset = 0)
        {
            _LOGGING_TRACE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _LOGGING_TRACE_ToByte(ref byte[] dst, _LOGGING_TRACE[,,,] src, int len = 1, int wordOffset = 0)
        {
            _LOGGING_TRACE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _LOGGING_TRACE_ToByte(ref byte[] dst, _LOGGING_TRACE[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _LOGGING_TRACE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _LOGGING_TRACE_ToByte(ref byte[] dst, _LOGGING_TRACE[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _LOGGING_TRACE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _LOGGING_TRACE_ToByte(ref byte[] dst, _LOGGING_TRACE[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _LOGGING_TRACE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _LOGGING_TRACE_ToByte(ref byte[] dst, _LOGGING_TRACE[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _LOGGING_TRACE_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_AXIS_CFG_ToByte(ref byte[] dst, _MC_AXIS_CFG src, int len = 1, int wordOffset = 0)
        {
            UshortToByte(ref dst, src.UnitCoordTrans, 1, 0 + wordOffset);
            DoubleToByte(ref dst, src.PosCycle, 1, 4 + wordOffset);
            UintToByte(ref dst, src.CoordTransDenominator, 1, 12 + wordOffset);
            UintToByte(ref dst, src.CoordTransNumerator, 1, 14 + wordOffset);
            UshortToByte(ref dst, src.SoftLimitCoordSystem, 1, 16 + wordOffset);
            UshortToByte(ref dst, src.UseSoftLimit, 1, 17 + wordOffset);
            DoubleToByte(ref dst, src.SoftLimitPositivePos, 1, 20 + wordOffset);
            DoubleToByte(ref dst, src.SoftLimitNegativePos, 1, 24 + wordOffset);
            UshortToByte(ref dst, src.AxisErrorSetting, 1, 28 + wordOffset);
            UshortToByte(ref dst, src.AxisCtrlSetting, 1, 29 + wordOffset);
            UshortToByte(ref dst, src.ServoEndCheckTime, 1, 30 + wordOffset);
            DoubleToByte(ref dst, src.BacklashCompensationMovement, 1, 32 + wordOffset);
            DoubleToByte(ref dst, src.ServoEndRange, 1, 36 + wordOffset);
            UshortToByte(ref dst, src.ChgToPosCtrlModeVelThresh, 1, 40 + wordOffset);
            IntToByte(ref dst, src.AbsEncUpperLim, 1, 42 + wordOffset);
            IntToByte(ref dst, src.AbsEncLowerLim, 1, 44 + wordOffset);
            UshortToByte(ref dst, src.Reserved, 54, 46 + wordOffset);
        }
        private static void _MC_AXIS_CFG_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_AXIS_CFG_ToByte(ref dst, ( _MC_AXIS_CFG ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_AXIS_CFG_WSIZE;
            }
        }
        public static void _MC_AXIS_CFG_ToByte(ref byte[] dst, _MC_AXIS_CFG[] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_CFG_ToByte(ref byte[] dst, _MC_AXIS_CFG[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_CFG_ToByte(ref byte[] dst, _MC_AXIS_CFG[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_CFG_ToByte(ref byte[] dst, _MC_AXIS_CFG[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_CFG_ToByte(ref byte[] dst, _MC_AXIS_CFG[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_CFG_ToByte(ref byte[] dst, _MC_AXIS_CFG[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_CFG_ToByte(ref byte[] dst, _MC_AXIS_CFG[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_CFG_ToByte(ref byte[] dst, _MC_AXIS_CFG[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_AXIS_CMP_CODE_ToByte(ref byte[] dst, _MC_AXIS_CMP_CODE src, int len = 1, int wordOffset = 0)
        {
            UshortToByte(ref dst, src.PosCtrlStart, 1, 2 + wordOffset);
            UshortToByte(ref dst, src.SetPosition, 1, 4 + wordOffset);
            UshortToByte(ref dst, src.ChgTargetPos, 1, 5 + wordOffset);
            UshortToByte(ref dst, src.ChgTargetVel, 1, 6 + wordOffset);
            UshortToByte(ref dst, src.Stop, 1, 7 + wordOffset);
            UshortToByte(ref dst, src.RestartPositioning, 1, 8 + wordOffset);
            UshortToByte(ref dst, src.MoveToNextPoint, 1, 9 + wordOffset);
            UshortToByte(ref dst, src.SuspendNextPositioning, 1, 10 + wordOffset);
            UshortToByte(ref dst, src.StopAtTargetPosition, 1, 11 + wordOffset);
            UshortToByte(ref dst, src.Homing, 1, 12 + wordOffset);
            UshortToByte(ref dst, src.MoveToBasePosition, 1, 13 + wordOffset);
            UshortToByte(ref dst, src.FastMoveToHome, 1, 14 + wordOffset);
            UshortToByte(ref dst, src.Teaching, 1, 15 + wordOffset);
            UshortToByte(ref dst, src.StartSpecialFunc, 1, 17 + wordOffset);
            UshortToByte(ref dst, src.ReleaseSpecialFunc, 1, 18 + wordOffset);
            UshortToByte(ref dst, src.ChgCtrlMode, 1, 19 + wordOffset);
            UshortToByte(ref dst, src.StartSyncCtrl, 1, 20 + wordOffset);
            UshortToByte(ref dst, src.ReleaseSyncCtrl, 1, 21 + wordOffset);
            UshortToByte(ref dst, src.ChgCam, 1, 22 + wordOffset);
            UshortToByte(ref dst, src.ReengageSyncTrqLimitClutch, 1, 23 + wordOffset);
        }
        private static void _MC_AXIS_CMP_CODE_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_AXIS_CMP_CODE_ToByte(ref dst, ( _MC_AXIS_CMP_CODE ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_AXIS_CMP_CODE_WSIZE;
            }
        }
        public static void _MC_AXIS_CMP_CODE_ToByte(ref byte[] dst, _MC_AXIS_CMP_CODE[] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_CMP_CODE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_CMP_CODE_ToByte(ref byte[] dst, _MC_AXIS_CMP_CODE[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_CMP_CODE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_CMP_CODE_ToByte(ref byte[] dst, _MC_AXIS_CMP_CODE[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_CMP_CODE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_CMP_CODE_ToByte(ref byte[] dst, _MC_AXIS_CMP_CODE[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_CMP_CODE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_CMP_CODE_ToByte(ref byte[] dst, _MC_AXIS_CMP_CODE[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_CMP_CODE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_CMP_CODE_ToByte(ref byte[] dst, _MC_AXIS_CMP_CODE[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_CMP_CODE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_CMP_CODE_ToByte(ref byte[] dst, _MC_AXIS_CMP_CODE[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_CMP_CODE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_CMP_CODE_ToByte(ref byte[] dst, _MC_AXIS_CMP_CODE[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_CMP_CODE_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_AXIS_CTRL_ToByte(ref byte[] dst, _MC_AXIS_CTRL src, int len = 1, int wordOffset = 0)
        {
            UshortToByte(ref dst, src.PointNo, 1, 0 + wordOffset);
            UshortToByte(ref dst, src.CtrlMode, 1, 1 + wordOffset);
            DoubleToByte(ref dst, src.SetPosition, 1, 4 + wordOffset);
            DoubleToByte(ref dst, src.ChgPositioningTargetPos, 1, 8 + wordOffset);
            DoubleToByte(ref dst, src.ChgPositioningTargetVel, 1, 12 + wordOffset);
            DoubleToByte(ref dst, src.ChgVel, 1, 16 + wordOffset);
            UshortToByte(ref dst, src.Override, 1, 20 + wordOffset);
            UshortToByte(ref dst, src.SelectSpecialFunc, 1, 21 + wordOffset);
            DoubleToByte(ref dst, src.AbsPosFollowUpCtrlCmdVal, 1, 24 + wordOffset);
            DoubleToByte(ref dst, src.SyncTypeFollowUpCtrlCmdVal, 1, 28 + wordOffset);
            DoubleToByte(ref dst, src.VelCtrlCmdVel, 1, 32 + wordOffset);
            DoubleToByte(ref dst, src.VelCtrlTrqLimit, 1, 36 + wordOffset);
            DoubleToByte(ref dst, src.VelCtrlTrqFeedforward, 1, 40 + wordOffset);
            DoubleToByte(ref dst, src.TrqCtrlCmdTrq, 1, 44 + wordOffset);
            DoubleToByte(ref dst, src.TrqCtrlVelLimit, 1, 48 + wordOffset);
            DoubleToByte(ref dst, src.PosCtrlTrqLimit, 1, 52 + wordOffset);
            DoubleToByte(ref dst, src.PosCtrlVelFeedforward, 1, 56 + wordOffset);
            DoubleToByte(ref dst, src.PosCtrlTrqFeedforward, 1, 60 + wordOffset);
            UshortToByte(ref dst, src.ChgSyncCamNo, 1, 64 + wordOffset);
            UshortToByte(ref dst, src.ChgSyncCamPos, 1, 65 + wordOffset);
            UshortToByte(ref dst, src.Controlword, 1, 68 + wordOffset);
            UshortToByte(ref dst, src.TouchProbeFunction, 1, 69 + wordOffset);
            UshortToByte(ref dst, src.Reserved, 30, 70 + wordOffset);
        }
        private static void _MC_AXIS_CTRL_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_AXIS_CTRL_ToByte(ref dst, ( _MC_AXIS_CTRL ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_AXIS_CTRL_WSIZE;
            }
        }
        public static void _MC_AXIS_CTRL_ToByte(ref byte[] dst, _MC_AXIS_CTRL[] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_CTRL_ToByte(ref byte[] dst, _MC_AXIS_CTRL[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_CTRL_ToByte(ref byte[] dst, _MC_AXIS_CTRL[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_CTRL_ToByte(ref byte[] dst, _MC_AXIS_CTRL[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_CTRL_ToByte(ref byte[] dst, _MC_AXIS_CTRL[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_CTRL_ToByte(ref byte[] dst, _MC_AXIS_CTRL[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_CTRL_ToByte(ref byte[] dst, _MC_AXIS_CTRL[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_CTRL_ToByte(ref byte[] dst, _MC_AXIS_CTRL[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_AXIS_GROUP_CFG_ToByte(ref byte[] dst, _MC_AXIS_GROUP_CFG src, int len = 1, int wordOffset = 0)
        {
            UshortToByte(ref dst, src.Axis, 16, 0 + wordOffset);
        }
        private static void _MC_AXIS_GROUP_CFG_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_AXIS_GROUP_CFG_ToByte(ref dst, ( _MC_AXIS_GROUP_CFG ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_AXIS_GROUP_CFG_WSIZE;
            }
        }
        public static void _MC_AXIS_GROUP_CFG_ToByte(ref byte[] dst, _MC_AXIS_GROUP_CFG[] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_GROUP_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_GROUP_CFG_ToByte(ref byte[] dst, _MC_AXIS_GROUP_CFG[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_GROUP_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_GROUP_CFG_ToByte(ref byte[] dst, _MC_AXIS_GROUP_CFG[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_GROUP_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_GROUP_CFG_ToByte(ref byte[] dst, _MC_AXIS_GROUP_CFG[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_GROUP_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_GROUP_CFG_ToByte(ref byte[] dst, _MC_AXIS_GROUP_CFG[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_GROUP_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_GROUP_CFG_ToByte(ref byte[] dst, _MC_AXIS_GROUP_CFG[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_GROUP_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_GROUP_CFG_ToByte(ref byte[] dst, _MC_AXIS_GROUP_CFG[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_GROUP_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_GROUP_CFG_ToByte(ref byte[] dst, _MC_AXIS_GROUP_CFG[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_GROUP_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_AXIS_GROUP_REF_ToByte(ref byte[] dst, _MC_AXIS_GROUP_REF src, int len = 1, int wordOffset = 0)
        {
            UshortToByte(ref dst, src.AxisGroupNo, 1, 0 + wordOffset);
        }
        private static void _MC_AXIS_GROUP_REF_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_AXIS_GROUP_REF_ToByte(ref dst, ( _MC_AXIS_GROUP_REF ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_AXIS_GROUP_REF_WSIZE;
            }
        }
        public static void _MC_AXIS_GROUP_REF_ToByte(ref byte[] dst, _MC_AXIS_GROUP_REF[] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_GROUP_REF_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_GROUP_REF_ToByte(ref byte[] dst, _MC_AXIS_GROUP_REF[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_GROUP_REF_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_GROUP_REF_ToByte(ref byte[] dst, _MC_AXIS_GROUP_REF[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_GROUP_REF_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_GROUP_REF_ToByte(ref byte[] dst, _MC_AXIS_GROUP_REF[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_GROUP_REF_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_GROUP_REF_ToByte(ref byte[] dst, _MC_AXIS_GROUP_REF[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_GROUP_REF_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_GROUP_REF_ToByte(ref byte[] dst, _MC_AXIS_GROUP_REF[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_GROUP_REF_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_GROUP_REF_ToByte(ref byte[] dst, _MC_AXIS_GROUP_REF[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_GROUP_REF_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_GROUP_REF_ToByte(ref byte[] dst, _MC_AXIS_GROUP_REF[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_GROUP_REF_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_AXIS_IO_STATUS_ToByte(ref byte[] dst, _MC_AXIS_IO_STATUS src, int len = 1, int wordOffset = 0)
        {
            BoolToByte(ref dst, src.PositiveLimit, 1, 0 + wordOffset, 0);
            BoolToByte(ref dst, src.NegativeLimit, 1, 0 + wordOffset, 1);
            BoolToByte(ref dst, src.HomeSensor, 1, 0 + wordOffset, 2);
            BoolToByte(ref dst, src.StopSensor, 1, 0 + wordOffset, 3);
            BoolToByte(ref dst, src.SyncCtrlExtInput, 1, 0 + wordOffset, 4);
            BoolToByte(ref dst, src.ServoEnd, 1, 0 + wordOffset, 6);
            BoolToByte(ref dst, src.ServoReady, 1, 0 + wordOffset, 7);
            BoolToByte(ref dst, src.DrvAlarm, 1, 0 + wordOffset, 8);
            BoolToByte(ref dst, src.ServoOn, 1, 0 + wordOffset, 14);
            BoolToByte(ref dst, src.Reserved, 1, 0 + wordOffset, 15);
        }
        private static void _MC_AXIS_IO_STATUS_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_AXIS_IO_STATUS_ToByte(ref dst, ( _MC_AXIS_IO_STATUS ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_AXIS_IO_STATUS_WSIZE;
            }
        }
        public static void _MC_AXIS_IO_STATUS_ToByte(ref byte[] dst, _MC_AXIS_IO_STATUS[] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_IO_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_IO_STATUS_ToByte(ref byte[] dst, _MC_AXIS_IO_STATUS[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_IO_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_IO_STATUS_ToByte(ref byte[] dst, _MC_AXIS_IO_STATUS[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_IO_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_IO_STATUS_ToByte(ref byte[] dst, _MC_AXIS_IO_STATUS[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_IO_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_IO_STATUS_ToByte(ref byte[] dst, _MC_AXIS_IO_STATUS[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_IO_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_IO_STATUS_ToByte(ref byte[] dst, _MC_AXIS_IO_STATUS[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_IO_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_IO_STATUS_ToByte(ref byte[] dst, _MC_AXIS_IO_STATUS[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_IO_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_IO_STATUS_ToByte(ref byte[] dst, _MC_AXIS_IO_STATUS[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_IO_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_AXIS_MOTION_FUNC_MAP_ToByte(ref byte[] dst, _MC_AXIS_MOTION_FUNC_MAP src, int len = 1, int wordOffset = 0)
        {
            BoolToByte(ref dst, src.PosCtrlAvl, 1, 0 + wordOffset, 0);
            BoolToByte(ref dst, src.VelCtrlAvl, 1, 0 + wordOffset, 1);
            BoolToByte(ref dst, src.TrqCtrlAvl, 1, 0 + wordOffset, 2);
            BoolToByte(ref dst, src.FeedbackTrqAvl, 1, 0 + wordOffset, 3);
            BoolToByte(ref dst, src.StopSensorAvl, 1, 0 + wordOffset, 4);
            BoolToByte(ref dst, src.HomingBaseAvl, 1, 0 + wordOffset, 8);
            BoolToByte(ref dst, src.HomingDogNoZAvl, 1, 0 + wordOffset, 9);
            BoolToByte(ref dst, src.HomingDogPressAvl, 1, 0 + wordOffset, 10);
            BoolToByte(ref dst, src.HomingLimitSwAvl, 1, 0 + wordOffset, 11);
            BoolToByte(ref dst, src.HomingImmZAvl, 1, 0 + wordOffset, 12);
            BoolToByte(ref dst, src.PosCtrlTrqLimitAvl, 1, 1 + wordOffset, 0);
            BoolToByte(ref dst, src.PosCtrlVelFeedforwardAvl, 1, 1 + wordOffset, 1);
            BoolToByte(ref dst, src.PosCtrlTrqFeedforwardAvl, 1, 1 + wordOffset, 2);
            BoolToByte(ref dst, src.VelCtrlTrqLimitAvl, 1, 1 + wordOffset, 3);
            BoolToByte(ref dst, src.VelCtrlTrqFeedforwardAvl, 1, 1 + wordOffset, 4);
            BoolToByte(ref dst, src.TrqCtrlVelLimitAvl, 1, 1 + wordOffset, 5);
            BoolToByte(ref dst, src.DrvAlarmCodeAvl, 1, 1 + wordOffset, 6);
            BoolToByte(ref dst, src.Reserved, 9, 1 + wordOffset, 7);
        }
        private static void _MC_AXIS_MOTION_FUNC_MAP_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_AXIS_MOTION_FUNC_MAP_ToByte(ref dst, ( _MC_AXIS_MOTION_FUNC_MAP ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_AXIS_MOTION_FUNC_MAP_WSIZE;
            }
        }
        public static void _MC_AXIS_MOTION_FUNC_MAP_ToByte(ref byte[] dst, _MC_AXIS_MOTION_FUNC_MAP[] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_MOTION_FUNC_MAP_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_MOTION_FUNC_MAP_ToByte(ref byte[] dst, _MC_AXIS_MOTION_FUNC_MAP[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_MOTION_FUNC_MAP_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_MOTION_FUNC_MAP_ToByte(ref byte[] dst, _MC_AXIS_MOTION_FUNC_MAP[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_MOTION_FUNC_MAP_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_MOTION_FUNC_MAP_ToByte(ref byte[] dst, _MC_AXIS_MOTION_FUNC_MAP[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_MOTION_FUNC_MAP_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_MOTION_FUNC_MAP_ToByte(ref byte[] dst, _MC_AXIS_MOTION_FUNC_MAP[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_MOTION_FUNC_MAP_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_MOTION_FUNC_MAP_ToByte(ref byte[] dst, _MC_AXIS_MOTION_FUNC_MAP[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_MOTION_FUNC_MAP_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_MOTION_FUNC_MAP_ToByte(ref byte[] dst, _MC_AXIS_MOTION_FUNC_MAP[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_MOTION_FUNC_MAP_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_MOTION_FUNC_MAP_ToByte(ref byte[] dst, _MC_AXIS_MOTION_FUNC_MAP[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_MOTION_FUNC_MAP_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_AXIS_STATUS_ToByte(ref byte[] dst, _MC_AXIS_STATUS src, int len = 1, int wordOffset = 0)
        {
            UshortToByte(ref dst, src.ErrorCode, 1, 0 + wordOffset);
            UshortToByte(ref dst, src.ErrorDetail, 5, 1 + wordOffset);
            UshortToByte(ref dst, src.WarningCode, 1, 6 + wordOffset);
            UshortToByte(ref dst, src.WarningDetail, 5, 7 + wordOffset);
            _MC_AXIS_IO_STATUS_ToByte(ref dst, src.IOStatus, 1, 12 + wordOffset);
            UshortToByte(ref dst, src.PosCtrlState, 1, 13 + wordOffset);
            DoubleToByte(ref dst, src.CmdPos, 1, 16 + wordOffset);
            DoubleToByte(ref dst, src.CmdVel, 1, 20 + wordOffset);
            IntToByte(ref dst, src.CmdPls, 1, 24 + wordOffset);
            DoubleToByte(ref dst, src.MechanicalPos, 1, 28 + wordOffset);
            UshortToByte(ref dst, src.CurrentPointNo, 1, 32 + wordOffset);
            UshortToByte(ref dst, src.MCode, 1, 33 + wordOffset);
            DoubleToByte(ref dst, src.TargetPos, 1, 36 + wordOffset);
            DoubleToByte(ref dst, src.InheritedVel, 1, 40 + wordOffset);
            UshortToByte(ref dst, src.CurrentCtrlMode, 1, 45 + wordOffset);
            IntToByte(ref dst, src.FeedbackPls, 1, 46 + wordOffset);
            DoubleToByte(ref dst, src.ActPos, 1, 48 + wordOffset);
            DoubleToByte(ref dst, src.ActVel, 1, 52 + wordOffset);
            UshortToByte(ref dst, src.DrvAlarmCode, 1, 56 + wordOffset);
            IntToByte(ref dst, src.EcatStatus, 1, 58 + wordOffset);
            UshortToByte(ref dst, src.DrvAlarmDetail1, 1, 60 + wordOffset);
            UshortToByte(ref dst, src.DrvAlarmDetail2, 1, 61 + wordOffset);
            UshortToByte(ref dst, src.EcatNodeAdr, 1, 62 + wordOffset);
            UshortToByte(ref dst, src.AxisIndex, 1, 63 + wordOffset);
            DoubleToByte(ref dst, src.TrqLimitMon, 1, 64 + wordOffset);
            DoubleToByte(ref dst, src.TrqFeedforwardMon, 1, 68 + wordOffset);
            DoubleToByte(ref dst, src.VelLimitMon, 1, 72 + wordOffset);
            DoubleToByte(ref dst, src.VelFeedforwardMon, 1, 76 + wordOffset);
            DoubleToByte(ref dst, src.FeedbackVel, 1, 80 + wordOffset);
            DoubleToByte(ref dst, src.FeedbackTrq, 1, 84 + wordOffset);
            IntToByte(ref dst, src.PosDeviation, 1, 88 + wordOffset);
            UshortToByte(ref dst, src.CurrentSettlingTime, 1, 90 + wordOffset);
            UshortToByte(ref dst, src.MaxSettlingTime, 1, 91 + wordOffset);
            _MC_AXIS_MOTION_FUNC_MAP_ToByte(ref dst, src.MotionFuncMapSetting, 1, 92 + wordOffset);
            UshortToByte(ref dst, src.StopSensorDetectionNum, 1, 94 + wordOffset);
            DoubleToByte(ref dst, src.StopSensorPos, 1, 96 + wordOffset);
            UshortToByte(ref dst, src.Reserved, 12, 100 + wordOffset);
        }
        private static void _MC_AXIS_STATUS_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_AXIS_STATUS_ToByte(ref dst, ( _MC_AXIS_STATUS ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_AXIS_STATUS_WSIZE;
            }
        }
        public static void _MC_AXIS_STATUS_ToByte(ref byte[] dst, _MC_AXIS_STATUS[] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_STATUS_ToByte(ref byte[] dst, _MC_AXIS_STATUS[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_STATUS_ToByte(ref byte[] dst, _MC_AXIS_STATUS[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_STATUS_ToByte(ref byte[] dst, _MC_AXIS_STATUS[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_STATUS_ToByte(ref byte[] dst, _MC_AXIS_STATUS[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_STATUS_ToByte(ref byte[] dst, _MC_AXIS_STATUS[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_STATUS_ToByte(ref byte[] dst, _MC_AXIS_STATUS[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_STATUS_ToByte(ref byte[] dst, _MC_AXIS_STATUS[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_AXIS_STATUS_BIT_ToByte(ref byte[] dst, _MC_AXIS_STATUS_BIT src, int len = 1, int wordOffset = 0)
        {
            BoolToByte(ref dst, src.PlsOutputDone, 1, 0 + wordOffset, 1);
            BoolToByte(ref dst, src.PositioningDone, 1, 0 + wordOffset, 2);
            BoolToByte(ref dst, src.MCodeStatus, 1, 0 + wordOffset, 7);
            BoolToByte(ref dst, src.AxisError, 1, 1 + wordOffset, 0);
            BoolToByte(ref dst, src.AxisWarning, 1, 1 + wordOffset, 1);
            BoolToByte(ref dst, src.InControl, 1, 1 + wordOffset, 3);
            BoolToByte(ref dst, src.ServoEnd, 1, 1 + wordOffset, 4);
            BoolToByte(ref dst, src.ServoReady, 1, 1 + wordOffset, 5);
            BoolToByte(ref dst, src.DrvAlarm, 1, 1 + wordOffset, 6);
            BoolToByte(ref dst, src.Jogging, 1, 1 + wordOffset, 13);
            BoolToByte(ref dst, src.HomeIsNotDefined, 1, 1 + wordOffset, 15);
            BoolToByte(ref dst, src.InSyncCtrl, 1, 2 + wordOffset, 2);
            BoolToByte(ref dst, src.MainClutchStatus, 1, 2 + wordOffset, 3);
            BoolToByte(ref dst, src.ChangingMainAxisPhaseCompensation, 1, 2 + wordOffset, 4);
            BoolToByte(ref dst, src.MainClutchEngaged, 1, 2 + wordOffset, 5);
            BoolToByte(ref dst, src.AuxClutchStatus, 1, 2 + wordOffset, 8);
            BoolToByte(ref dst, src.ChangingAuxAxisPhaseCompensation, 1, 2 + wordOffset, 9);
            BoolToByte(ref dst, src.AuxClutchEngaged, 1, 2 + wordOffset, 10);
            BoolToByte(ref dst, src.ChangingSyncVariableGear, 1, 2 + wordOffset, 13);
            BoolToByte(ref dst, src.TrqLimitClutchOff, 1, 3 + wordOffset, 1);
            BoolToByte(ref dst, src.DrvLimit, 1, 3 + wordOffset, 2);
            BoolToByte(ref dst, src.DrvWarning, 1, 3 + wordOffset, 6);
            BoolToByte(ref dst, src.Reserved, 64, 4 + wordOffset, 0);
        }
        private static void _MC_AXIS_STATUS_BIT_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_AXIS_STATUS_BIT_ToByte(ref dst, ( _MC_AXIS_STATUS_BIT ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_AXIS_STATUS_BIT_WSIZE;
            }
        }
        public static void _MC_AXIS_STATUS_BIT_ToByte(ref byte[] dst, _MC_AXIS_STATUS_BIT[] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_STATUS_BIT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_STATUS_BIT_ToByte(ref byte[] dst, _MC_AXIS_STATUS_BIT[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_STATUS_BIT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_STATUS_BIT_ToByte(ref byte[] dst, _MC_AXIS_STATUS_BIT[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_STATUS_BIT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_STATUS_BIT_ToByte(ref byte[] dst, _MC_AXIS_STATUS_BIT[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_STATUS_BIT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_STATUS_BIT_ToByte(ref byte[] dst, _MC_AXIS_STATUS_BIT[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_STATUS_BIT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_STATUS_BIT_ToByte(ref byte[] dst, _MC_AXIS_STATUS_BIT[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_STATUS_BIT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_STATUS_BIT_ToByte(ref byte[] dst, _MC_AXIS_STATUS_BIT[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_STATUS_BIT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_STATUS_BIT_ToByte(ref byte[] dst, _MC_AXIS_STATUS_BIT[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_STATUS_BIT_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_AXIS_SYNC_STATUS_ToByte(ref byte[] dst, _MC_AXIS_SYNC_STATUS src, int len = 1, int wordOffset = 0)
        {
            DoubleToByte(ref dst, src.MainAxisPhaseCompensation, 1, 4 + wordOffset);
            DoubleToByte(ref dst, src.AuxAxisPhaseCompensation, 1, 8 + wordOffset);
            DoubleToByte(ref dst, src.StepAngleCompensation, 1, 12 + wordOffset);
            DoubleToByte(ref dst, src.MainAxisPhase, 1, 16 + wordOffset);
            DoubleToByte(ref dst, src.MainClutchInputAxisPhase, 1, 20 + wordOffset);
            DoubleToByte(ref dst, src.MainClutchInputAxisPos, 1, 24 + wordOffset);
            DoubleToByte(ref dst, src.MainClutchOutputAxisPhase, 1, 28 + wordOffset);
            DoubleToByte(ref dst, src.MainClutchOutputAxisPos, 1, 32 + wordOffset);
            DoubleToByte(ref dst, src.AuxClutchInputAxisPhase, 1, 36 + wordOffset);
            DoubleToByte(ref dst, src.AuxClutchInputAxisPos, 1, 40 + wordOffset);
            DoubleToByte(ref dst, src.AuxClutchOutputAxisPhase, 1, 44 + wordOffset);
            DoubleToByte(ref dst, src.AuxClutchOutputAxisPos, 1, 48 + wordOffset);
            DoubleToByte(ref dst, src.TrqLimitClutchInputAxisPhase, 1, 52 + wordOffset);
            DoubleToByte(ref dst, src.TrqLimitClutchInputAxisPos, 1, 56 + wordOffset);
            DoubleToByte(ref dst, src.TrqLimitClutchOutputAxisPhase, 1, 60 + wordOffset);
            DoubleToByte(ref dst, src.TrqLimitClutchOutputAxisPos, 1, 64 + wordOffset);
            DoubleToByte(ref dst, src.CamInputAxisPhase, 1, 68 + wordOffset);
            DoubleToByte(ref dst, src.CamOutputRelativePos, 1, 72 + wordOffset);
            UshortToByte(ref dst, src.CurrentCamNo, 1, 76 + wordOffset);
            UshortToByte(ref dst, src.ContactOutputCurrentParamNo, 1, 77 + wordOffset);
            UshortToByte(ref dst, src.Reserved, 2, 78 + wordOffset);
        }
        private static void _MC_AXIS_SYNC_STATUS_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_AXIS_SYNC_STATUS_ToByte(ref dst, ( _MC_AXIS_SYNC_STATUS ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_AXIS_SYNC_STATUS_WSIZE;
            }
        }
        public static void _MC_AXIS_SYNC_STATUS_ToByte(ref byte[] dst, _MC_AXIS_SYNC_STATUS[] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_SYNC_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_SYNC_STATUS_ToByte(ref byte[] dst, _MC_AXIS_SYNC_STATUS[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_SYNC_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_SYNC_STATUS_ToByte(ref byte[] dst, _MC_AXIS_SYNC_STATUS[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_SYNC_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_SYNC_STATUS_ToByte(ref byte[] dst, _MC_AXIS_SYNC_STATUS[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_SYNC_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_SYNC_STATUS_ToByte(ref byte[] dst, _MC_AXIS_SYNC_STATUS[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_SYNC_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_SYNC_STATUS_ToByte(ref byte[] dst, _MC_AXIS_SYNC_STATUS[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_SYNC_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_SYNC_STATUS_ToByte(ref byte[] dst, _MC_AXIS_SYNC_STATUS[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_SYNC_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_SYNC_STATUS_ToByte(ref byte[] dst, _MC_AXIS_SYNC_STATUS[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_SYNC_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_CAM_SECTION_ToByte(ref byte[] dst, _MC_CAM_SECTION src, int len = 1, int wordOffset = 0)
        {
            UintToByte(ref dst, src.Phase, 1, 0 + wordOffset);
            UshortToByte(ref dst, src.Curve, 1, 2 + wordOffset);
            DoubleToByte(ref dst, src.Displacement, 1, 4 + wordOffset);
            ShortToByte(ref dst, src.StartVel, 1, 8 + wordOffset);
            ShortToByte(ref dst, src.EndVel, 1, 9 + wordOffset);
            ShortToByte(ref dst, src.StartAcc, 1, 10 + wordOffset);
            ShortToByte(ref dst, src.EndAcc, 1, 11 + wordOffset);
        }
        private static void _MC_CAM_SECTION_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_CAM_SECTION_ToByte(ref dst, ( _MC_CAM_SECTION ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_CAM_SECTION_WSIZE;
            }
        }
        public static void _MC_CAM_SECTION_ToByte(ref byte[] dst, _MC_CAM_SECTION[] src, int len = 1, int wordOffset = 0)
        {
            _MC_CAM_SECTION_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_CAM_SECTION_ToByte(ref byte[] dst, _MC_CAM_SECTION[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_CAM_SECTION_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_CAM_SECTION_ToByte(ref byte[] dst, _MC_CAM_SECTION[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_CAM_SECTION_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_CAM_SECTION_ToByte(ref byte[] dst, _MC_CAM_SECTION[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_CAM_SECTION_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_CAM_SECTION_ToByte(ref byte[] dst, _MC_CAM_SECTION[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_CAM_SECTION_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_CAM_SECTION_ToByte(ref byte[] dst, _MC_CAM_SECTION[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_CAM_SECTION_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_CAM_SECTION_ToByte(ref byte[] dst, _MC_CAM_SECTION[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_CAM_SECTION_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_CAM_SECTION_ToByte(ref byte[] dst, _MC_CAM_SECTION[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_CAM_SECTION_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_COMMON_CMP_CODE_ToByte(ref byte[] dst, _MC_COMMON_CMP_CODE src, int len = 1, int wordOffset = 0)
        {
            UshortToByte(ref dst, src.FlashRomWrite, 1, 0 + wordOffset);
            UshortToByte(ref dst, src.SyncContactParamChg, 1, 1 + wordOffset);
            UshortToByte(ref dst, src.Reserved, 6, 2 + wordOffset);
        }
        private static void _MC_COMMON_CMP_CODE_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_COMMON_CMP_CODE_ToByte(ref dst, ( _MC_COMMON_CMP_CODE ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_COMMON_CMP_CODE_WSIZE;
            }
        }
        public static void _MC_COMMON_CMP_CODE_ToByte(ref byte[] dst, _MC_COMMON_CMP_CODE[] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_CMP_CODE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_CMP_CODE_ToByte(ref byte[] dst, _MC_COMMON_CMP_CODE[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_CMP_CODE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_CMP_CODE_ToByte(ref byte[] dst, _MC_COMMON_CMP_CODE[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_CMP_CODE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_CMP_CODE_ToByte(ref byte[] dst, _MC_COMMON_CMP_CODE[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_CMP_CODE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_CMP_CODE_ToByte(ref byte[] dst, _MC_COMMON_CMP_CODE[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_CMP_CODE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_CMP_CODE_ToByte(ref byte[] dst, _MC_COMMON_CMP_CODE[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_CMP_CODE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_CMP_CODE_ToByte(ref byte[] dst, _MC_COMMON_CMP_CODE[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_CMP_CODE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_CMP_CODE_ToByte(ref byte[] dst, _MC_COMMON_CMP_CODE[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_CMP_CODE_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_COMMON_CTRL_ToByte(ref byte[] dst, _MC_COMMON_CTRL src, int len = 1, int wordOffset = 0)
        {
            IntToByte(ref dst, src.ExtRefCmdVal, 48, 0 + wordOffset);
        }
        private static void _MC_COMMON_CTRL_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_COMMON_CTRL_ToByte(ref dst, ( _MC_COMMON_CTRL ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_COMMON_CTRL_WSIZE;
            }
        }
        public static void _MC_COMMON_CTRL_ToByte(ref byte[] dst, _MC_COMMON_CTRL[] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_CTRL_ToByte(ref byte[] dst, _MC_COMMON_CTRL[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_CTRL_ToByte(ref byte[] dst, _MC_COMMON_CTRL[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_CTRL_ToByte(ref byte[] dst, _MC_COMMON_CTRL[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_CTRL_ToByte(ref byte[] dst, _MC_COMMON_CTRL[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_CTRL_ToByte(ref byte[] dst, _MC_COMMON_CTRL[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_CTRL_ToByte(ref byte[] dst, _MC_COMMON_CTRL[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_CTRL_ToByte(ref byte[] dst, _MC_COMMON_CTRL[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_CTRL_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_COMMON_PERFORMANCE_ToByte(ref byte[] dst, _MC_COMMON_PERFORMANCE src, int len = 1, int wordOffset = 0)
        {
            UintToByte(ref dst, src.CurrentCycleTime, 1, 0 + wordOffset);
            UintToByte(ref dst, src.MaxCycleTime, 1, 2 + wordOffset);
            UshortToByte(ref dst, src.CurrentLoadFactor, 1, 4 + wordOffset);
            UshortToByte(ref dst, src.MaxLoadFactor, 1, 5 + wordOffset);
            UshortToByte(ref dst, src.Reserved, 6, 6 + wordOffset);
        }
        private static void _MC_COMMON_PERFORMANCE_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_COMMON_PERFORMANCE_ToByte(ref dst, ( _MC_COMMON_PERFORMANCE ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_COMMON_PERFORMANCE_WSIZE;
            }
        }
        public static void _MC_COMMON_PERFORMANCE_ToByte(ref byte[] dst, _MC_COMMON_PERFORMANCE[] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_PERFORMANCE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_PERFORMANCE_ToByte(ref byte[] dst, _MC_COMMON_PERFORMANCE[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_PERFORMANCE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_PERFORMANCE_ToByte(ref byte[] dst, _MC_COMMON_PERFORMANCE[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_PERFORMANCE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_PERFORMANCE_ToByte(ref byte[] dst, _MC_COMMON_PERFORMANCE[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_PERFORMANCE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_PERFORMANCE_ToByte(ref byte[] dst, _MC_COMMON_PERFORMANCE[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_PERFORMANCE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_PERFORMANCE_ToByte(ref byte[] dst, _MC_COMMON_PERFORMANCE[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_PERFORMANCE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_PERFORMANCE_ToByte(ref byte[] dst, _MC_COMMON_PERFORMANCE[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_PERFORMANCE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_PERFORMANCE_ToByte(ref byte[] dst, _MC_COMMON_PERFORMANCE[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_PERFORMANCE_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_COMMON_STATUS_BIT_ToByte(ref byte[] dst, _MC_COMMON_STATUS_BIT src, int len = 1, int wordOffset = 0)
        {
            BoolToByte(ref dst, src.Enable, 1, 0 + wordOffset, 0);
            BoolToByte(ref dst, src.EnableError, 1, 0 + wordOffset, 1);
            BoolToByte(ref dst, src.UnitError, 1, 0 + wordOffset, 3);
            BoolToByte(ref dst, src.AxisError, 1, 0 + wordOffset, 4);
            BoolToByte(ref dst, src.AxisWarning, 1, 0 + wordOffset, 5);
            BoolToByte(ref dst, src.TestRunning, 1, 0 + wordOffset, 6);
            BoolToByte(ref dst, src.Reserved, 48, 1 + wordOffset, 0);
        }
        private static void _MC_COMMON_STATUS_BIT_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_COMMON_STATUS_BIT_ToByte(ref dst, ( _MC_COMMON_STATUS_BIT ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_COMMON_STATUS_BIT_WSIZE;
            }
        }
        public static void _MC_COMMON_STATUS_BIT_ToByte(ref byte[] dst, _MC_COMMON_STATUS_BIT[] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_STATUS_BIT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_STATUS_BIT_ToByte(ref byte[] dst, _MC_COMMON_STATUS_BIT[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_STATUS_BIT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_STATUS_BIT_ToByte(ref byte[] dst, _MC_COMMON_STATUS_BIT[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_STATUS_BIT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_STATUS_BIT_ToByte(ref byte[] dst, _MC_COMMON_STATUS_BIT[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_STATUS_BIT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_STATUS_BIT_ToByte(ref byte[] dst, _MC_COMMON_STATUS_BIT[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_STATUS_BIT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_STATUS_BIT_ToByte(ref byte[] dst, _MC_COMMON_STATUS_BIT[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_STATUS_BIT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_STATUS_BIT_ToByte(ref byte[] dst, _MC_COMMON_STATUS_BIT[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_STATUS_BIT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_STATUS_BIT_ToByte(ref byte[] dst, _MC_COMMON_STATUS_BIT[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_STATUS_BIT_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_POINT_PARAM_ToByte(ref byte[] dst, _MC_POINT_PARAM src, int len = 1, int wordOffset = 0)
        {
            UshortToByte(ref dst, src.PositioningMode, 1, 0 + wordOffset);
            UshortToByte(ref dst, src.ContinuousMode, 1, 1 + wordOffset);
            UshortToByte(ref dst, src.NextPointNo, 1, 2 + wordOffset);
            UshortToByte(ref dst, src.MCodeNo, 1, 3 + wordOffset);
            DoubleToByte(ref dst, src.TargetPos, 1, 4 + wordOffset);
            UshortToByte(ref dst, src.DwellTime, 1, 8 + wordOffset);
            UshortToByte(ref dst, src.AxisGroupNo, 1, 9 + wordOffset);
            DoubleToByte(ref dst, src.StopSensorMovement_ArcPos, 1, 12 + wordOffset);
            DoubleToByte(ref dst, src.TargetVel, 1, 16 + wordOffset);
            DoubleToByte(ref dst, src.Acceleration, 1, 20 + wordOffset);
            DoubleToByte(ref dst, src.Deceleration, 1, 24 + wordOffset);
            DoubleToByte(ref dst, src.AuxArcRadius, 1, 28 + wordOffset);
            DoubleToByte(ref dst, src.TrqLimit, 1, 32 + wordOffset);
            UshortToByte(ref dst, src.Revolution, 1, 36 + wordOffset);
            UshortToByte(ref dst, src.Reserved, 3, 37 + wordOffset);
        }
        private static void _MC_POINT_PARAM_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_POINT_PARAM_ToByte(ref dst, ( _MC_POINT_PARAM ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_POINT_PARAM_WSIZE;
            }
        }
        public static void _MC_POINT_PARAM_ToByte(ref byte[] dst, _MC_POINT_PARAM[] src, int len = 1, int wordOffset = 0)
        {
            _MC_POINT_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_POINT_PARAM_ToByte(ref byte[] dst, _MC_POINT_PARAM[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_POINT_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_POINT_PARAM_ToByte(ref byte[] dst, _MC_POINT_PARAM[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_POINT_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_POINT_PARAM_ToByte(ref byte[] dst, _MC_POINT_PARAM[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_POINT_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_POINT_PARAM_ToByte(ref byte[] dst, _MC_POINT_PARAM[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_POINT_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_POINT_PARAM_ToByte(ref byte[] dst, _MC_POINT_PARAM[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_POINT_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_POINT_PARAM_ToByte(ref byte[] dst, _MC_POINT_PARAM[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_POINT_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_POINT_PARAM_ToByte(ref byte[] dst, _MC_POINT_PARAM[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_POINT_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_POINT_PARAM_AXIS_ToByte(ref byte[] dst, _MC_POINT_PARAM_AXIS src, int len = 1, int wordOffset = 0)
        {
            _MC_POINT_PARAM_ToByte(ref dst, src.Point, 50, 0 + wordOffset);
        }
        private static void _MC_POINT_PARAM_AXIS_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_POINT_PARAM_AXIS_ToByte(ref dst, ( _MC_POINT_PARAM_AXIS ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_POINT_PARAM_AXIS_WSIZE;
            }
        }
        public static void _MC_POINT_PARAM_AXIS_ToByte(ref byte[] dst, _MC_POINT_PARAM_AXIS[] src, int len = 1, int wordOffset = 0)
        {
            _MC_POINT_PARAM_AXIS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_POINT_PARAM_AXIS_ToByte(ref byte[] dst, _MC_POINT_PARAM_AXIS[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_POINT_PARAM_AXIS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_POINT_PARAM_AXIS_ToByte(ref byte[] dst, _MC_POINT_PARAM_AXIS[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_POINT_PARAM_AXIS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_POINT_PARAM_AXIS_ToByte(ref byte[] dst, _MC_POINT_PARAM_AXIS[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_POINT_PARAM_AXIS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_POINT_PARAM_AXIS_ToByte(ref byte[] dst, _MC_POINT_PARAM_AXIS[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_POINT_PARAM_AXIS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_POINT_PARAM_AXIS_ToByte(ref byte[] dst, _MC_POINT_PARAM_AXIS[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_POINT_PARAM_AXIS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_POINT_PARAM_AXIS_ToByte(ref byte[] dst, _MC_POINT_PARAM_AXIS[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_POINT_PARAM_AXIS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_POINT_PARAM_AXIS_ToByte(ref byte[] dst, _MC_POINT_PARAM_AXIS[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_POINT_PARAM_AXIS_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_POS_CFG_ToByte(ref byte[] dst, _MC_POS_CFG src, int len = 1, int wordOffset = 0)
        {
            UshortToByte(ref dst, src.CommonSetting1, 1, 0 + wordOffset);
            UshortToByte(ref dst, src.CommonSetting2, 1, 1 + wordOffset);
            DoubleToByte(ref dst, src.OperationStartVel, 1, 4 + wordOffset);
            DoubleToByte(ref dst, src.OperationMaxVel, 1, 8 + wordOffset);
            DoubleToByte(ref dst, src.OperationAcc, 1, 12 + wordOffset);
            DoubleToByte(ref dst, src.OperationDec, 1, 16 + wordOffset);
            UshortToByte(ref dst, src.OperationAccDecCurveRatio, 1, 20 + wordOffset);
            UshortToByte(ref dst, src.OperationAccDecCurve, 1, 21 + wordOffset);
            DoubleToByte(ref dst, src.JogAcc, 1, 24 + wordOffset);
            DoubleToByte(ref dst, src.JogDec, 1, 28 + wordOffset);
            DoubleToByte(ref dst, src.JogStartVel, 1, 32 + wordOffset);
            DoubleToByte(ref dst, src.JogFastVel, 1, 36 + wordOffset);
            DoubleToByte(ref dst, src.JogInchingMovement, 1, 40 + wordOffset);
            UshortToByte(ref dst, src.JogAccDecCurveRatio, 1, 44 + wordOffset);
            UshortToByte(ref dst, src.JogAccDecCurve, 1, 45 + wordOffset);
            UshortToByte(ref dst, src.HomingSetting, 1, 46 + wordOffset);
            UshortToByte(ref dst, src.HomingAccDecCurveRatio, 1, 47 + wordOffset);
            DoubleToByte(ref dst, src.HomingStartVel, 1, 48 + wordOffset);
            DoubleToByte(ref dst, src.HomingCreepVel, 1, 52 + wordOffset);
            DoubleToByte(ref dst, src.HomingVel, 1, 56 + wordOffset);
            DoubleToByte(ref dst, src.HomingAcc, 1, 60 + wordOffset);
            DoubleToByte(ref dst, src.HomingDec, 1, 64 + wordOffset);
            DoubleToByte(ref dst, src.HomingPos, 1, 68 + wordOffset);
            DoubleToByte(ref dst, src.HomingBasePos, 1, 72 + wordOffset);
            DoubleToByte(ref dst, src.HomingMovementAfterDogOn, 1, 76 + wordOffset);
            UshortToByte(ref dst, src.HomingMethod, 1, 80 + wordOffset);
            UshortToByte(ref dst, src.HomingDwellTime, 1, 81 + wordOffset);
            UshortToByte(ref dst, src.HomingPressTrqTime, 1, 83 + wordOffset);
            DoubleToByte(ref dst, src.HomingPressTrqThresh, 1, 84 + wordOffset);
            DoubleToByte(ref dst, src.AbsPosFollowUpCtrlVel, 1, 88 + wordOffset);
            DoubleToByte(ref dst, src.AbsPosFollowUpCtrlAcc, 1, 92 + wordOffset);
            DoubleToByte(ref dst, src.AbsPosFollowUpCtrlDec, 1, 96 + wordOffset);
            UintToByte(ref dst, src.SyncTypeFollowUpCtrlGearNumerator, 1, 100 + wordOffset);
            UintToByte(ref dst, src.SyncTypeFollowUpCtrlGearDenominator, 1, 102 + wordOffset);
            UshortToByte(ref dst, src.SyncTypeFollowUpCtrlOutputFilter, 1, 104 + wordOffset);
            UshortToByte(ref dst, src.Reserved, 95, 105 + wordOffset);
        }
        private static void _MC_POS_CFG_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_POS_CFG_ToByte(ref dst, ( _MC_POS_CFG ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_POS_CFG_WSIZE;
            }
        }
        public static void _MC_POS_CFG_ToByte(ref byte[] dst, _MC_POS_CFG[] src, int len = 1, int wordOffset = 0)
        {
            _MC_POS_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_POS_CFG_ToByte(ref byte[] dst, _MC_POS_CFG[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_POS_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_POS_CFG_ToByte(ref byte[] dst, _MC_POS_CFG[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_POS_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_POS_CFG_ToByte(ref byte[] dst, _MC_POS_CFG[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_POS_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_POS_CFG_ToByte(ref byte[] dst, _MC_POS_CFG[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_POS_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_POS_CFG_ToByte(ref byte[] dst, _MC_POS_CFG[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_POS_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_POS_CFG_ToByte(ref byte[] dst, _MC_POS_CFG[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_POS_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_POS_CFG_ToByte(ref byte[] dst, _MC_POS_CFG[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_POS_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_SYNC_CONTACT_OUTPUT_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT src, int len = 1, int wordOffset = 0)
        {
            BoolToByte(ref dst, src.Output, 16, 0 + wordOffset, 0);
        }
        private static void _MC_SYNC_CONTACT_OUTPUT_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_SYNC_CONTACT_OUTPUT_ToByte(ref dst, ( _MC_SYNC_CONTACT_OUTPUT ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_SYNC_CONTACT_OUTPUT_WSIZE;
            }
        }
        public static void _MC_SYNC_CONTACT_OUTPUT_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT[] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_CONTACT_OUTPUT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_CONTACT_OUTPUT_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_CONTACT_OUTPUT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_CONTACT_OUTPUT_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_CONTACT_OUTPUT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_CONTACT_OUTPUT_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_CONTACT_OUTPUT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_CONTACT_OUTPUT_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_CONTACT_OUTPUT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_CONTACT_OUTPUT_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_CONTACT_OUTPUT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_CONTACT_OUTPUT_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_CONTACT_OUTPUT_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_CONTACT_OUTPUT_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_CONTACT_OUTPUT_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_SYNC_CONTACT_OUTPUT_SUB_CFG_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT_SUB_CFG src, int len = 1, int wordOffset = 0)
        {
            DoubleToByte(ref dst, src.OnVal, 1, 0 + wordOffset);
            DoubleToByte(ref dst, src.OffVal, 1, 4 + wordOffset);
            UshortToByte(ref dst, src.OutputDst, 1, 8 + wordOffset);
            UshortToByte(ref dst, src.Reserved, 3, 9 + wordOffset);
        }
        private static void _MC_SYNC_CONTACT_OUTPUT_SUB_CFG_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_SYNC_CONTACT_OUTPUT_SUB_CFG_ToByte(ref dst, ( _MC_SYNC_CONTACT_OUTPUT_SUB_CFG ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_SYNC_CONTACT_OUTPUT_SUB_CFG_WSIZE;
            }
        }
        public static void _MC_SYNC_CONTACT_OUTPUT_SUB_CFG_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT_SUB_CFG[] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_CONTACT_OUTPUT_SUB_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_CONTACT_OUTPUT_SUB_CFG_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT_SUB_CFG[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_CONTACT_OUTPUT_SUB_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_CONTACT_OUTPUT_SUB_CFG_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT_SUB_CFG[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_CONTACT_OUTPUT_SUB_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_CONTACT_OUTPUT_SUB_CFG_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT_SUB_CFG[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_CONTACT_OUTPUT_SUB_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_CONTACT_OUTPUT_SUB_CFG_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT_SUB_CFG[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_CONTACT_OUTPUT_SUB_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_CONTACT_OUTPUT_SUB_CFG_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT_SUB_CFG[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_CONTACT_OUTPUT_SUB_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_CONTACT_OUTPUT_SUB_CFG_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT_SUB_CFG[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_CONTACT_OUTPUT_SUB_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_CONTACT_OUTPUT_SUB_CFG_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT_SUB_CFG[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_CONTACT_OUTPUT_SUB_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_SYNC_EXT_INPUT_CFG_ToByte(ref byte[] dst, _MC_SYNC_EXT_INPUT_CFG src, int len = 1, int wordOffset = 0)
        {
            UshortToByte(ref dst, src.BaseSetting, 1, 0 + wordOffset);
            UintToByte(ref dst, src.DevNo, 1, 2 + wordOffset);
            IntToByte(ref dst, src.RingCounterMin, 1, 4 + wordOffset);
            IntToByte(ref dst, src.RingCounterMax, 1, 6 + wordOffset);
        }
        private static void _MC_SYNC_EXT_INPUT_CFG_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_SYNC_EXT_INPUT_CFG_ToByte(ref dst, ( _MC_SYNC_EXT_INPUT_CFG ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_SYNC_EXT_INPUT_CFG_WSIZE;
            }
        }
        public static void _MC_SYNC_EXT_INPUT_CFG_ToByte(ref byte[] dst, _MC_SYNC_EXT_INPUT_CFG[] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_EXT_INPUT_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_EXT_INPUT_CFG_ToByte(ref byte[] dst, _MC_SYNC_EXT_INPUT_CFG[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_EXT_INPUT_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_EXT_INPUT_CFG_ToByte(ref byte[] dst, _MC_SYNC_EXT_INPUT_CFG[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_EXT_INPUT_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_EXT_INPUT_CFG_ToByte(ref byte[] dst, _MC_SYNC_EXT_INPUT_CFG[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_EXT_INPUT_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_EXT_INPUT_CFG_ToByte(ref byte[] dst, _MC_SYNC_EXT_INPUT_CFG[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_EXT_INPUT_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_EXT_INPUT_CFG_ToByte(ref byte[] dst, _MC_SYNC_EXT_INPUT_CFG[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_EXT_INPUT_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_EXT_INPUT_CFG_ToByte(ref byte[] dst, _MC_SYNC_EXT_INPUT_CFG[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_EXT_INPUT_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_EXT_INPUT_CFG_ToByte(ref byte[] dst, _MC_SYNC_EXT_INPUT_CFG[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_EXT_INPUT_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_SYNC_PARAM_ToByte(ref byte[] dst, _MC_SYNC_PARAM src, int len = 1, int wordOffset = 0)
        {
            DoubleToByte(ref dst, src.InputAxisCycle, 1, 0 + wordOffset);
            UshortToByte(ref dst, src.UnitAndPrecision, 1, 4 + wordOffset);
            UshortToByte(ref dst, src.ClutchOffSlippingTimeAtDecStop, 1, 5 + wordOffset);
            UshortToByte(ref dst, src.InputAxisPhaseInitMethod, 1, 6 + wordOffset);
            DoubleToByte(ref dst, src.MainAxisInitialPhase, 1, 8 + wordOffset);
            DoubleToByte(ref dst, src.MainAxisInitialPhaseAfterCompensation, 1, 12 + wordOffset);
            DoubleToByte(ref dst, src.MainClutchInputInitialPhase, 1, 16 + wordOffset);
            DoubleToByte(ref dst, src.AuxClutchInputInitialPhase, 1, 20 + wordOffset);
            UshortToByte(ref dst, src.CamInClutchOutPhaseInitMethod, 1, 24 + wordOffset);
            DoubleToByte(ref dst, src.MainClutchOutputInitialPhase, 1, 28 + wordOffset);
            DoubleToByte(ref dst, src.AuxClutchOutputInitialPhase, 1, 32 + wordOffset);
            DoubleToByte(ref dst, src.TrqLimitClutchInputInitialPhase, 1, 36 + wordOffset);
            DoubleToByte(ref dst, src.CamInputInitialPhase, 1, 40 + wordOffset);
            DoubleToByte(ref dst, src.CamOutputBasePos, 1, 44 + wordOffset);
            UshortToByte(ref dst, src.MainAxis1Input, 1, 48 + wordOffset);
            UshortToByte(ref dst, src.MainAxis1CoordTrans, 1, 49 + wordOffset);
            UintToByte(ref dst, src.MainAxis1CoordTransNumerator, 1, 50 + wordOffset);
            UintToByte(ref dst, src.MainAxis1CoordTransDenominator, 1, 52 + wordOffset);
            UshortToByte(ref dst, src.MainAxis2Input, 1, 54 + wordOffset);
            UshortToByte(ref dst, src.MainAxis2CoordTrans, 1, 55 + wordOffset);
            UintToByte(ref dst, src.MainAxis2CoordTransNumerator, 1, 56 + wordOffset);
            UintToByte(ref dst, src.MainAxis2CoordTransDenominator, 1, 58 + wordOffset);
            UshortToByte(ref dst, src.AuxAxisInput, 1, 60 + wordOffset);
            UshortToByte(ref dst, src.AuxAxisCoordTrans, 1, 61 + wordOffset);
            UintToByte(ref dst, src.AuxAxisCoordTransNumerator, 1, 62 + wordOffset);
            UintToByte(ref dst, src.AuxAxisCoordTransDenominator, 1, 64 + wordOffset);
            DoubleToByte(ref dst, src.MainAxisPhaseCompensationCmdVal, 1, 68 + wordOffset);
            UshortToByte(ref dst, src.MainAxisPhaseCompensationChgMethod, 1, 72 + wordOffset);
            UshortToByte(ref dst, src.MainAxisPhaseCompensationChgTime, 1, 73 + wordOffset);
            DoubleToByte(ref dst, src.AuxAxisPhaseCompensationCmdVal, 1, 76 + wordOffset);
            UshortToByte(ref dst, src.AuxAxisPhaseCompensationChgMethod, 1, 80 + wordOffset);
            UshortToByte(ref dst, src.AuxAxisPhaseCompensationChgTime, 1, 81 + wordOffset);
            DoubleToByte(ref dst, src.StepAngleCompensationBaseVel, 1, 84 + wordOffset);
            DoubleToByte(ref dst, src.StepAngleCompensationBaseValue, 1, 88 + wordOffset);
            UshortToByte(ref dst, src.StepAngleCompensationChgMethod, 1, 92 + wordOffset);
            UshortToByte(ref dst, src.StepAngleCompensationChgTime, 1, 93 + wordOffset);
            IntToByte(ref dst, src.VariableGearRatioNumerator, 1, 94 + wordOffset);
            UintToByte(ref dst, src.VariableGearRatioDenominator, 1, 96 + wordOffset);
            UshortToByte(ref dst, src.VariableGearRatioChgMethod, 1, 98 + wordOffset);
            UshortToByte(ref dst, src.VariableGearRatioChgTime, 1, 99 + wordOffset);
            UshortToByte(ref dst, src.MainClutchOnCondition, 1, 100 + wordOffset);
            UshortToByte(ref dst, src.MainClutchOnEngagingMethod, 1, 101 + wordOffset);
            UshortToByte(ref dst, src.MainClutchOnSlippingMode, 1, 102 + wordOffset);
            UshortToByte(ref dst, src.MainClutchOnDisableMethod, 1, 103 + wordOffset);
            DoubleToByte(ref dst, src.MainClutchOnSettingVal, 1, 104 + wordOffset);
            DoubleToByte(ref dst, src.MainClutchOnDelay, 1, 108 + wordOffset);
            DoubleToByte(ref dst, src.MainClutchOnSlippage, 1, 112 + wordOffset);
            UshortToByte(ref dst, src.MainClutchOnSlippingCurve, 1, 116 + wordOffset);
            UshortToByte(ref dst, src.MainClutchOnSlippingTime, 1, 117 + wordOffset);
            UshortToByte(ref dst, src.MainClutchOnFollowingTime, 1, 119 + wordOffset);
            DoubleToByte(ref dst, src.MainClutchOnFollowUpMovement, 1, 120 + wordOffset);
            UshortToByte(ref dst, src.MainClutchOffCondition, 1, 124 + wordOffset);
            UshortToByte(ref dst, src.MainClutchOffEngagingMethod, 1, 125 + wordOffset);
            UshortToByte(ref dst, src.MainClutchOffSlippingMode, 1, 126 + wordOffset);
            UshortToByte(ref dst, src.MainClutchOffDisableMethod, 1, 127 + wordOffset);
            DoubleToByte(ref dst, src.MainClutchOffSettingVal, 1, 128 + wordOffset);
            DoubleToByte(ref dst, src.MainClutchOffDelay, 1, 132 + wordOffset);
            DoubleToByte(ref dst, src.MainClutchOffSlippage, 1, 136 + wordOffset);
            UshortToByte(ref dst, src.MainClutchOffSlippingCurve, 1, 140 + wordOffset);
            UshortToByte(ref dst, src.MainClutchOffSlippingTime, 1, 141 + wordOffset);
            UshortToByte(ref dst, src.AuxClutchOnCondition, 1, 144 + wordOffset);
            UshortToByte(ref dst, src.AuxClutchOnEngagingMethod, 1, 145 + wordOffset);
            UshortToByte(ref dst, src.AuxClutchOnSlippingMode, 1, 146 + wordOffset);
            UshortToByte(ref dst, src.AuxClutchOnDisableMethod, 1, 147 + wordOffset);
            DoubleToByte(ref dst, src.AuxClutchOnSettingVal, 1, 148 + wordOffset);
            DoubleToByte(ref dst, src.AuxClutchOnDelay, 1, 152 + wordOffset);
            DoubleToByte(ref dst, src.AuxClutchOnSlippage, 1, 156 + wordOffset);
            UshortToByte(ref dst, src.AuxClutchOnSlippingCurve, 1, 160 + wordOffset);
            UshortToByte(ref dst, src.AuxClutchOnSlippingTime, 1, 161 + wordOffset);
            UshortToByte(ref dst, src.AuxClutchOffCondition, 1, 164 + wordOffset);
            UshortToByte(ref dst, src.AuxClutchOffEngagingMethod, 1, 165 + wordOffset);
            UshortToByte(ref dst, src.AuxClutchOffSlippingMode, 1, 166 + wordOffset);
            UshortToByte(ref dst, src.AuxClutchOffDisableMethod, 1, 167 + wordOffset);
            DoubleToByte(ref dst, src.AuxClutchOffSettingVal, 1, 168 + wordOffset);
            DoubleToByte(ref dst, src.AuxClutchOffDelay, 1, 172 + wordOffset);
            DoubleToByte(ref dst, src.AuxClutchOffSlippage, 1, 176 + wordOffset);
            UshortToByte(ref dst, src.AuxClutchOffSlippingCurve, 1, 180 + wordOffset);
            UshortToByte(ref dst, src.AuxClutchOffSlippingTime, 1, 181 + wordOffset);
            UshortToByte(ref dst, src.CamDataNo, 1, 182 + wordOffset);
            UshortToByte(ref dst, src.ContactOutputNo, 1, 183 + wordOffset);
            DoubleToByte(ref dst, src.CamStroke, 1, 184 + wordOffset);
            UshortToByte(ref dst, src.SimMechanicalSyncStopMethod, 1, 188 + wordOffset);
            UshortToByte(ref dst, src.TrqLimitClutchEngagingMethod, 1, 189 + wordOffset);
            UshortToByte(ref dst, src.OutputFilterTimeConst, 1, 190 + wordOffset);
            DoubleToByte(ref dst, src.SimMechanicalSyncStopTrq, 1, 192 + wordOffset);
            DoubleToByte(ref dst, src.TrqLimitClutchOutputJogVel, 1, 196 + wordOffset);
        }
        private static void _MC_SYNC_PARAM_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_SYNC_PARAM_ToByte(ref dst, ( _MC_SYNC_PARAM ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_SYNC_PARAM_WSIZE;
            }
        }
        public static void _MC_SYNC_PARAM_ToByte(ref byte[] dst, _MC_SYNC_PARAM[] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_PARAM_ToByte(ref byte[] dst, _MC_SYNC_PARAM[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_PARAM_ToByte(ref byte[] dst, _MC_SYNC_PARAM[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_PARAM_ToByte(ref byte[] dst, _MC_SYNC_PARAM[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_PARAM_ToByte(ref byte[] dst, _MC_SYNC_PARAM[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_PARAM_ToByte(ref byte[] dst, _MC_SYNC_PARAM[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_PARAM_ToByte(ref byte[] dst, _MC_SYNC_PARAM[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_PARAM_ToByte(ref byte[] dst, _MC_SYNC_PARAM[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _OPERATION_RECORDER_ToByte(ref byte[] dst, _OPERATION_RECORDER src, int len = 1, int wordOffset = 0)
        {
            BoolToByte(ref dst, src.SaveRequest, 1, 0 + wordOffset, 0);
            BoolToByte(ref dst, src.InAction, 1, 0 + wordOffset, 1);
            BoolToByte(ref dst, src.SaveTriggerMonitor, 1, 0 + wordOffset, 2);
            BoolToByte(ref dst, src.SaveBusy, 1, 0 + wordOffset, 3);
            BoolToByte(ref dst, src.Collecting, 1, 0 + wordOffset, 4);
            BoolToByte(ref dst, src.SettingError, 1, 0 + wordOffset, 5);
            BoolToByte(ref dst, src.SaveComplete, 1, 0 + wordOffset, 7);
            BoolToByte(ref dst, src.SaveError, 1, 0 + wordOffset, 8);
            BoolToByte(ref dst, src.BufferShortage, 1, 0 + wordOffset, 9);
            BoolToByte(ref dst, src.BufferAllSaveMode, 1, 0 + wordOffset, 14);
            IntToByte(ref dst, src.AverageSamplingPeriod, 1, 2 + wordOffset);
            IntToByte(ref dst, src.AverageChangedDeviceNum, 1, 4 + wordOffset);
            IntToByte(ref dst, src.MaxCollectingPeriod, 1, 6 + wordOffset);
            UshortToByte(ref dst, src.SaveFinCode, 1, 20 + wordOffset);
            UshortToByte(ref dst, src.SaveCounter, 1, 22 + wordOffset);
            UshortToByte(ref dst, src.SaveProgressInfo1, 1, 24 + wordOffset);
            UshortToByte(ref dst, src.SaveProgressInfo2, 1, 25 + wordOffset);
            UshortToByte(ref dst, src.SaveProgress, 1, 26 + wordOffset);
            StringToByte(ref dst, src.SavePath, 1, 30 + wordOffset, 321);
            UshortToByte(ref dst, src.Reserved, 9, 191 + wordOffset);
        }
        private static void _OPERATION_RECORDER_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _OPERATION_RECORDER_ToByte(ref dst, ( _OPERATION_RECORDER ) src.GetValue(indices), len, wordOffset);
                wordOffset += _OPERATION_RECORDER_WSIZE;
            }
        }
        public static void _OPERATION_RECORDER_ToByte(ref byte[] dst, _OPERATION_RECORDER[] src, int len = 1, int wordOffset = 0)
        {
            _OPERATION_RECORDER_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _OPERATION_RECORDER_ToByte(ref byte[] dst, _OPERATION_RECORDER[,] src, int len = 1, int wordOffset = 0)
        {
            _OPERATION_RECORDER_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _OPERATION_RECORDER_ToByte(ref byte[] dst, _OPERATION_RECORDER[,,] src, int len = 1, int wordOffset = 0)
        {
            _OPERATION_RECORDER_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _OPERATION_RECORDER_ToByte(ref byte[] dst, _OPERATION_RECORDER[,,,] src, int len = 1, int wordOffset = 0)
        {
            _OPERATION_RECORDER_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _OPERATION_RECORDER_ToByte(ref byte[] dst, _OPERATION_RECORDER[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _OPERATION_RECORDER_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _OPERATION_RECORDER_ToByte(ref byte[] dst, _OPERATION_RECORDER[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _OPERATION_RECORDER_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _OPERATION_RECORDER_ToByte(ref byte[] dst, _OPERATION_RECORDER[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _OPERATION_RECORDER_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _OPERATION_RECORDER_ToByte(ref byte[] dst, _OPERATION_RECORDER[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _OPERATION_RECORDER_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _PROGRAM_INFO_ToByte(ref byte[] dst, _PROGRAM_INFO src, int len = 1, int wordOffset = 0)
        {
            UintToByte(ref dst, src.ScanTime, 1, 0 + wordOffset);
            UintToByte(ref dst, src.EndProcTime, 1, 2 + wordOffset);
            UintToByte(ref dst, src.MinScanTime, 1, 4 + wordOffset);
            UintToByte(ref dst, src.MaxScanTime, 1, 6 + wordOffset);
            UintToByte(ref dst, src.FixScanTimeSet, 1, 8 + wordOffset);
            UintToByte(ref dst, src.EndProcTimeSet, 1, 10 + wordOffset);
            UintToByte(ref dst, src.ExcessConstantScanTime, 1, 12 + wordOffset);
            UintToByte(ref dst, src.ExcessEndProcTime, 1, 14 + wordOffset);
            UshortToByte(ref dst, src.ProgramErrorDetail, 1, 23 + wordOffset);
            BoolToByte(ref dst, src.FixScanTimeEnable, 1, 24 + wordOffset, 3);
            BoolToByte(ref dst, src.FixTimeExcess, 1, 24 + wordOffset, 4);
            BoolToByte(ref dst, src.OCPDisabled, 1, 24 + wordOffset, 5);
            BoolToByte(ref dst, src.BackupBattError, 1, 24 + wordOffset, 6);
            BoolToByte(ref dst, src.ScanTimeMaxMinClear, 1, 24 + wordOffset, 7);
            BoolToByte(ref dst, src.FixEndProcTimeEnable, 1, 24 + wordOffset, 8);
            BoolToByte(ref dst, src.TimeError, 1, 24 + wordOffset, 11);
            BoolToByte(ref dst, src.ProjectPasswordAuthDisabled, 1, 24 + wordOffset, 14);
            UshortToByte(ref dst, src.Reserved, 1, 25 + wordOffset);
        }
        private static void _PROGRAM_INFO_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _PROGRAM_INFO_ToByte(ref dst, ( _PROGRAM_INFO ) src.GetValue(indices), len, wordOffset);
                wordOffset += _PROGRAM_INFO_WSIZE;
            }
        }
        public static void _PROGRAM_INFO_ToByte(ref byte[] dst, _PROGRAM_INFO[] src, int len = 1, int wordOffset = 0)
        {
            _PROGRAM_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _PROGRAM_INFO_ToByte(ref byte[] dst, _PROGRAM_INFO[,] src, int len = 1, int wordOffset = 0)
        {
            _PROGRAM_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _PROGRAM_INFO_ToByte(ref byte[] dst, _PROGRAM_INFO[,,] src, int len = 1, int wordOffset = 0)
        {
            _PROGRAM_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _PROGRAM_INFO_ToByte(ref byte[] dst, _PROGRAM_INFO[,,,] src, int len = 1, int wordOffset = 0)
        {
            _PROGRAM_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _PROGRAM_INFO_ToByte(ref byte[] dst, _PROGRAM_INFO[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _PROGRAM_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _PROGRAM_INFO_ToByte(ref byte[] dst, _PROGRAM_INFO[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _PROGRAM_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _PROGRAM_INFO_ToByte(ref byte[] dst, _PROGRAM_INFO[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _PROGRAM_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _PROGRAM_INFO_ToByte(ref byte[] dst, _PROGRAM_INFO[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _PROGRAM_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _PROJECT_INFO_ToByte(ref byte[] dst, _PROJECT_INFO src, int len = 1, int wordOffset = 0)
        {
            StringToByte(ref dst, src.ProjectName, 1, 0 + wordOffset, 65);
            UshortToByte(ref dst, src.SensorInstExecCount, 1, 34 + wordOffset);
            UshortToByte(ref dst, src.PrjPasswordCertFailCount, 1, 35 + wordOffset);
            UshortToByte(ref dst, src.PrjPasswordCertFailTotal, 1, 36 + wordOffset);
            UshortToByte(ref dst, src.CpuFuncVersion, 1, 38 + wordOffset);
            UshortToByte(ref dst, src.ProjectVersion, 1, 45 + wordOffset);
        }
        private static void _PROJECT_INFO_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _PROJECT_INFO_ToByte(ref dst, ( _PROJECT_INFO ) src.GetValue(indices), len, wordOffset);
                wordOffset += _PROJECT_INFO_WSIZE;
            }
        }
        public static void _PROJECT_INFO_ToByte(ref byte[] dst, _PROJECT_INFO[] src, int len = 1, int wordOffset = 0)
        {
            _PROJECT_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _PROJECT_INFO_ToByte(ref byte[] dst, _PROJECT_INFO[,] src, int len = 1, int wordOffset = 0)
        {
            _PROJECT_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _PROJECT_INFO_ToByte(ref byte[] dst, _PROJECT_INFO[,,] src, int len = 1, int wordOffset = 0)
        {
            _PROJECT_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _PROJECT_INFO_ToByte(ref byte[] dst, _PROJECT_INFO[,,,] src, int len = 1, int wordOffset = 0)
        {
            _PROJECT_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _PROJECT_INFO_ToByte(ref byte[] dst, _PROJECT_INFO[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _PROJECT_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _PROJECT_INFO_ToByte(ref byte[] dst, _PROJECT_INFO[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _PROJECT_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _PROJECT_INFO_ToByte(ref byte[] dst, _PROJECT_INFO[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _PROJECT_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _PROJECT_INFO_ToByte(ref byte[] dst, _PROJECT_INFO[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _PROJECT_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _PROJECT_RECIPE_SAVE_LOAD_ToByte(ref byte[] dst, _PROJECT_RECIPE_SAVE_LOAD src, int len = 1, int wordOffset = 0)
        {
            BoolToByte(ref dst, src.Request, 1, 0 + wordOffset, 0);
            BoolToByte(ref dst, src.Busy, 1, 0 + wordOffset, 1);
            BoolToByte(ref dst, src.Complete, 1, 0 + wordOffset, 2);
            BoolToByte(ref dst, src.Error, 1, 0 + wordOffset, 3);
            UshortToByte(ref dst, src.DriveNumber, 1, 1 + wordOffset);
            UshortToByte(ref dst, src.FolderNumber, 1, 2 + wordOffset);
            UshortToByte(ref dst, src.CompleteDriveNumber, 1, 3 + wordOffset);
            UshortToByte(ref dst, src.CompleteFolderNumber, 1, 4 + wordOffset);
            UshortToByte(ref dst, src.FinCode, 1, 5 + wordOffset);
        }
        private static void _PROJECT_RECIPE_SAVE_LOAD_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _PROJECT_RECIPE_SAVE_LOAD_ToByte(ref dst, ( _PROJECT_RECIPE_SAVE_LOAD ) src.GetValue(indices), len, wordOffset);
                wordOffset += _PROJECT_RECIPE_SAVE_LOAD_WSIZE;
            }
        }
        public static void _PROJECT_RECIPE_SAVE_LOAD_ToByte(ref byte[] dst, _PROJECT_RECIPE_SAVE_LOAD[] src, int len = 1, int wordOffset = 0)
        {
            _PROJECT_RECIPE_SAVE_LOAD_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _PROJECT_RECIPE_SAVE_LOAD_ToByte(ref byte[] dst, _PROJECT_RECIPE_SAVE_LOAD[,] src, int len = 1, int wordOffset = 0)
        {
            _PROJECT_RECIPE_SAVE_LOAD_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _PROJECT_RECIPE_SAVE_LOAD_ToByte(ref byte[] dst, _PROJECT_RECIPE_SAVE_LOAD[,,] src, int len = 1, int wordOffset = 0)
        {
            _PROJECT_RECIPE_SAVE_LOAD_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _PROJECT_RECIPE_SAVE_LOAD_ToByte(ref byte[] dst, _PROJECT_RECIPE_SAVE_LOAD[,,,] src, int len = 1, int wordOffset = 0)
        {
            _PROJECT_RECIPE_SAVE_LOAD_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _PROJECT_RECIPE_SAVE_LOAD_ToByte(ref byte[] dst, _PROJECT_RECIPE_SAVE_LOAD[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _PROJECT_RECIPE_SAVE_LOAD_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _PROJECT_RECIPE_SAVE_LOAD_ToByte(ref byte[] dst, _PROJECT_RECIPE_SAVE_LOAD[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _PROJECT_RECIPE_SAVE_LOAD_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _PROJECT_RECIPE_SAVE_LOAD_ToByte(ref byte[] dst, _PROJECT_RECIPE_SAVE_LOAD[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _PROJECT_RECIPE_SAVE_LOAD_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _PROJECT_RECIPE_SAVE_LOAD_ToByte(ref byte[] dst, _PROJECT_RECIPE_SAVE_LOAD[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _PROJECT_RECIPE_SAVE_LOAD_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _RECIPE_SAVE_ToByte(ref byte[] dst, _RECIPE_SAVE src, int len = 1, int wordOffset = 0)
        {
            BoolToByte(ref dst, src.Request, 1, 0 + wordOffset, 0);
            BoolToByte(ref dst, src.Busy, 1, 0 + wordOffset, 1);
            BoolToByte(ref dst, src.Complete, 1, 0 + wordOffset, 2);
            BoolToByte(ref dst, src.Error, 1, 0 + wordOffset, 3);
            UshortToByte(ref dst, src.DriveNumber, 1, 1 + wordOffset);
            UshortToByte(ref dst, src.InputFolderNumber, 1, 2 + wordOffset);
            UshortToByte(ref dst, src.OutputFolderNumber, 1, 4 + wordOffset);
            UshortToByte(ref dst, src.FinCode, 1, 5 + wordOffset);
        }
        private static void _RECIPE_SAVE_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _RECIPE_SAVE_ToByte(ref dst, ( _RECIPE_SAVE ) src.GetValue(indices), len, wordOffset);
                wordOffset += _RECIPE_SAVE_WSIZE;
            }
        }
        public static void _RECIPE_SAVE_ToByte(ref byte[] dst, _RECIPE_SAVE[] src, int len = 1, int wordOffset = 0)
        {
            _RECIPE_SAVE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _RECIPE_SAVE_ToByte(ref byte[] dst, _RECIPE_SAVE[,] src, int len = 1, int wordOffset = 0)
        {
            _RECIPE_SAVE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _RECIPE_SAVE_ToByte(ref byte[] dst, _RECIPE_SAVE[,,] src, int len = 1, int wordOffset = 0)
        {
            _RECIPE_SAVE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _RECIPE_SAVE_ToByte(ref byte[] dst, _RECIPE_SAVE[,,,] src, int len = 1, int wordOffset = 0)
        {
            _RECIPE_SAVE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _RECIPE_SAVE_ToByte(ref byte[] dst, _RECIPE_SAVE[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _RECIPE_SAVE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _RECIPE_SAVE_ToByte(ref byte[] dst, _RECIPE_SAVE[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _RECIPE_SAVE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _RECIPE_SAVE_ToByte(ref byte[] dst, _RECIPE_SAVE[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _RECIPE_SAVE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _RECIPE_SAVE_ToByte(ref byte[] dst, _RECIPE_SAVE[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _RECIPE_SAVE_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _SOCKET_STATUS_ToByte(ref byte[] dst, _SOCKET_STATUS src, int len = 1, int wordOffset = 0)
        {
            UshortToByte(ref dst, src.SocketStatus, 1, 0 + wordOffset);
            UshortToByte(ref dst, src.TCPConnStatus, 1, 1 + wordOffset);
            UshortToByte(ref dst, src.MyPortNo, 1, 2 + wordOffset);
            StringToByte(ref dst, src.ConnAddress, 1, 3 + wordOffset, 16);
            UshortToByte(ref dst, src.ConnPortNo, 1, 11 + wordOffset);
        }
        private static void _SOCKET_STATUS_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _SOCKET_STATUS_ToByte(ref dst, ( _SOCKET_STATUS ) src.GetValue(indices), len, wordOffset);
                wordOffset += _SOCKET_STATUS_WSIZE;
            }
        }
        public static void _SOCKET_STATUS_ToByte(ref byte[] dst, _SOCKET_STATUS[] src, int len = 1, int wordOffset = 0)
        {
            _SOCKET_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _SOCKET_STATUS_ToByte(ref byte[] dst, _SOCKET_STATUS[,] src, int len = 1, int wordOffset = 0)
        {
            _SOCKET_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _SOCKET_STATUS_ToByte(ref byte[] dst, _SOCKET_STATUS[,,] src, int len = 1, int wordOffset = 0)
        {
            _SOCKET_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _SOCKET_STATUS_ToByte(ref byte[] dst, _SOCKET_STATUS[,,,] src, int len = 1, int wordOffset = 0)
        {
            _SOCKET_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _SOCKET_STATUS_ToByte(ref byte[] dst, _SOCKET_STATUS[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _SOCKET_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _SOCKET_STATUS_ToByte(ref byte[] dst, _SOCKET_STATUS[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _SOCKET_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _SOCKET_STATUS_ToByte(ref byte[] dst, _SOCKET_STATUS[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _SOCKET_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _SOCKET_STATUS_ToByte(ref byte[] dst, _SOCKET_STATUS[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _SOCKET_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _STORAGE_ToByte(ref byte[] dst, _STORAGE src, int len = 1, int wordOffset = 0)
        {
            BoolToByte(ref dst, src.MemCardMountReq, 1, 0 + wordOffset, 0);
            BoolToByte(ref dst, src.MemCardUnmountReq, 1, 0 + wordOffset, 1);
            BoolToByte(ref dst, src.MemCardInUse, 1, 0 + wordOffset, 2);
            BoolToByte(ref dst, src.MemCardRecognized, 1, 0 + wordOffset, 3);
            BoolToByte(ref dst, src.MemCardExist, 1, 0 + wordOffset, 4);
            BoolToByte(ref dst, src.CpuMemoryMountReq, 1, 0 + wordOffset, 8);
            BoolToByte(ref dst, src.CpuMemoryUnmountReq, 1, 0 + wordOffset, 9);
            BoolToByte(ref dst, src.CpuMemoryInUse, 1, 0 + wordOffset, 10);
            BoolToByte(ref dst, src.CpuMemoryRecognized, 1, 0 + wordOffset, 11);
            _AUTOLOAD_CTRL_ToByte(ref dst, src.AutoLoad, 1, 3 + wordOffset);
            _AUTOLOAD_CTRL_ToByte(ref dst, src.RunLoad, 1, 10 + wordOffset);
            _PROJECT_RECIPE_SAVE_LOAD_ToByte(ref dst, src.ProjectSave, 1, 20 + wordOffset);
            _PROJECT_RECIPE_SAVE_LOAD_ToByte(ref dst, src.ProjectLoad, 1, 30 + wordOffset);
            _RECIPE_SAVE_ToByte(ref dst, src.RecipeSave, 1, 40 + wordOffset);
            _PROJECT_RECIPE_SAVE_LOAD_ToByte(ref dst, src.RecipeLoad, 1, 50 + wordOffset);
            _CPU_MEMORY_SAVE_ToByte(ref dst, src.CpuMemorySave, 1, 60 + wordOffset);
            BoolToByte(ref dst, src.StorageFBIsRAMMode, 1, 61 + wordOffset, 7);
            BoolToByte(ref dst, src.ProjectBackupBusy, 1, 61 + wordOffset, 8);
            BoolToByte(ref dst, src.LoggingTraceBusy, 1, 61 + wordOffset, 10);
            BoolToByte(ref dst, src.LoggingInternalBufferOverflow, 1, 61 + wordOffset, 11);
            UshortToByte(ref dst, src.PowerOffDuringStorageAccess, 1, 70 + wordOffset);
            UshortToByte(ref dst, src.MemoryCardRetryCount, 1, 71 + wordOffset);
            UshortToByte(ref dst, src.MemoryCardErrorCount, 1, 72 + wordOffset);
            UshortToByte(ref dst, src.MemoryCardResetDelay, 1, 74 + wordOffset);
            UintToByte(ref dst, src.UsageCpuMemory, 1, 80 + wordOffset);
        }
        private static void _STORAGE_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _STORAGE_ToByte(ref dst, ( _STORAGE ) src.GetValue(indices), len, wordOffset);
                wordOffset += _STORAGE_WSIZE;
            }
        }
        public static void _STORAGE_ToByte(ref byte[] dst, _STORAGE[] src, int len = 1, int wordOffset = 0)
        {
            _STORAGE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _STORAGE_ToByte(ref byte[] dst, _STORAGE[,] src, int len = 1, int wordOffset = 0)
        {
            _STORAGE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _STORAGE_ToByte(ref byte[] dst, _STORAGE[,,] src, int len = 1, int wordOffset = 0)
        {
            _STORAGE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _STORAGE_ToByte(ref byte[] dst, _STORAGE[,,,] src, int len = 1, int wordOffset = 0)
        {
            _STORAGE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _STORAGE_ToByte(ref byte[] dst, _STORAGE[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _STORAGE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _STORAGE_ToByte(ref byte[] dst, _STORAGE[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _STORAGE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _STORAGE_ToByte(ref byte[] dst, _STORAGE[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _STORAGE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _STORAGE_ToByte(ref byte[] dst, _STORAGE[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _STORAGE_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _STRING_TO_VARIABLE_PARAM_ToByte(ref byte[] dst, _STRING_TO_VARIABLE_PARAM src, int len = 1, int wordOffset = 0)
        {
            UshortToByte(ref dst, src.Delimiter, 1, 0 + wordOffset);
            BoolToByte(ref dst, src.Hex, 1, 1 + wordOffset, 0);
        }
        private static void _STRING_TO_VARIABLE_PARAM_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _STRING_TO_VARIABLE_PARAM_ToByte(ref dst, ( _STRING_TO_VARIABLE_PARAM ) src.GetValue(indices), len, wordOffset);
                wordOffset += _STRING_TO_VARIABLE_PARAM_WSIZE;
            }
        }
        public static void _STRING_TO_VARIABLE_PARAM_ToByte(ref byte[] dst, _STRING_TO_VARIABLE_PARAM[] src, int len = 1, int wordOffset = 0)
        {
            _STRING_TO_VARIABLE_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _STRING_TO_VARIABLE_PARAM_ToByte(ref byte[] dst, _STRING_TO_VARIABLE_PARAM[,] src, int len = 1, int wordOffset = 0)
        {
            _STRING_TO_VARIABLE_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _STRING_TO_VARIABLE_PARAM_ToByte(ref byte[] dst, _STRING_TO_VARIABLE_PARAM[,,] src, int len = 1, int wordOffset = 0)
        {
            _STRING_TO_VARIABLE_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _STRING_TO_VARIABLE_PARAM_ToByte(ref byte[] dst, _STRING_TO_VARIABLE_PARAM[,,,] src, int len = 1, int wordOffset = 0)
        {
            _STRING_TO_VARIABLE_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _STRING_TO_VARIABLE_PARAM_ToByte(ref byte[] dst, _STRING_TO_VARIABLE_PARAM[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _STRING_TO_VARIABLE_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _STRING_TO_VARIABLE_PARAM_ToByte(ref byte[] dst, _STRING_TO_VARIABLE_PARAM[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _STRING_TO_VARIABLE_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _STRING_TO_VARIABLE_PARAM_ToByte(ref byte[] dst, _STRING_TO_VARIABLE_PARAM[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _STRING_TO_VARIABLE_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _STRING_TO_VARIABLE_PARAM_ToByte(ref byte[] dst, _STRING_TO_VARIABLE_PARAM[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _STRING_TO_VARIABLE_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _UNIT_ID_ADR_ToByte(ref byte[] dst, _UNIT_ID_ADR src, int len = 1, int wordOffset = 0)
        {
            UshortToByte(ref dst, src.UnitNo, 1, 0 + wordOffset);
            UintToByte(ref dst, src.RelayAdr, 1, 2 + wordOffset);
            UintToByte(ref dst, src.DmAdr, 1, 4 + wordOffset);
        }
        private static void _UNIT_ID_ADR_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _UNIT_ID_ADR_ToByte(ref dst, ( _UNIT_ID_ADR ) src.GetValue(indices), len, wordOffset);
                wordOffset += _UNIT_ID_ADR_WSIZE;
            }
        }
        public static void _UNIT_ID_ADR_ToByte(ref byte[] dst, _UNIT_ID_ADR[] src, int len = 1, int wordOffset = 0)
        {
            _UNIT_ID_ADR_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _UNIT_ID_ADR_ToByte(ref byte[] dst, _UNIT_ID_ADR[,] src, int len = 1, int wordOffset = 0)
        {
            _UNIT_ID_ADR_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _UNIT_ID_ADR_ToByte(ref byte[] dst, _UNIT_ID_ADR[,,] src, int len = 1, int wordOffset = 0)
        {
            _UNIT_ID_ADR_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _UNIT_ID_ADR_ToByte(ref byte[] dst, _UNIT_ID_ADR[,,,] src, int len = 1, int wordOffset = 0)
        {
            _UNIT_ID_ADR_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _UNIT_ID_ADR_ToByte(ref byte[] dst, _UNIT_ID_ADR[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _UNIT_ID_ADR_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _UNIT_ID_ADR_ToByte(ref byte[] dst, _UNIT_ID_ADR[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _UNIT_ID_ADR_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _UNIT_ID_ADR_ToByte(ref byte[] dst, _UNIT_ID_ADR[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _UNIT_ID_ADR_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _UNIT_ID_ADR_ToByte(ref byte[] dst, _UNIT_ID_ADR[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _UNIT_ID_ADR_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _UNIT_SYNCHRONIZE_ToByte(ref byte[] dst, _UNIT_SYNCHRONIZE src, int len = 1, int wordOffset = 0)
        {
            UintToByte(ref dst, src.RefreshStartTimeDelay, 1, 0 + wordOffset);
            UintToByte(ref dst, src.RefreshFinishTimeDelay, 1, 2 + wordOffset);
            UintToByte(ref dst, src.RefreshStartTimeMaxDelay, 1, 4 + wordOffset);
            UintToByte(ref dst, src.RefreshFinishTimeMaxDelay, 1, 6 + wordOffset);
            UintToByte(ref dst, src.RefreshExecutionTime, 1, 8 + wordOffset);
            BoolToByte(ref dst, src.RefreshIntervalOver, 1, 10 + wordOffset, 0);
            UshortToByte(ref dst, src.Reserved, 1, 11 + wordOffset);
        }
        private static void _UNIT_SYNCHRONIZE_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _UNIT_SYNCHRONIZE_ToByte(ref dst, ( _UNIT_SYNCHRONIZE ) src.GetValue(indices), len, wordOffset);
                wordOffset += _UNIT_SYNCHRONIZE_WSIZE;
            }
        }
        public static void _UNIT_SYNCHRONIZE_ToByte(ref byte[] dst, _UNIT_SYNCHRONIZE[] src, int len = 1, int wordOffset = 0)
        {
            _UNIT_SYNCHRONIZE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _UNIT_SYNCHRONIZE_ToByte(ref byte[] dst, _UNIT_SYNCHRONIZE[,] src, int len = 1, int wordOffset = 0)
        {
            _UNIT_SYNCHRONIZE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _UNIT_SYNCHRONIZE_ToByte(ref byte[] dst, _UNIT_SYNCHRONIZE[,,] src, int len = 1, int wordOffset = 0)
        {
            _UNIT_SYNCHRONIZE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _UNIT_SYNCHRONIZE_ToByte(ref byte[] dst, _UNIT_SYNCHRONIZE[,,,] src, int len = 1, int wordOffset = 0)
        {
            _UNIT_SYNCHRONIZE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _UNIT_SYNCHRONIZE_ToByte(ref byte[] dst, _UNIT_SYNCHRONIZE[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _UNIT_SYNCHRONIZE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _UNIT_SYNCHRONIZE_ToByte(ref byte[] dst, _UNIT_SYNCHRONIZE[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _UNIT_SYNCHRONIZE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _UNIT_SYNCHRONIZE_ToByte(ref byte[] dst, _UNIT_SYNCHRONIZE[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _UNIT_SYNCHRONIZE_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _UNIT_SYNCHRONIZE_ToByte(ref byte[] dst, _UNIT_SYNCHRONIZE[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _UNIT_SYNCHRONIZE_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _VARIABLE_TO_STRING_PARAM_ToByte(ref byte[] dst, _VARIABLE_TO_STRING_PARAM src, int len = 1, int wordOffset = 0)
        {
            UshortToByte(ref dst, src.Delimiter, 1, 0 + wordOffset);
            UshortToByte(ref dst, src.CrLfCount, 1, 1 + wordOffset);
            UshortToByte(ref dst, src.EndStr, 1, 2 + wordOffset);
            BoolToByte(ref dst, src.FixedDigit, 1, 3 + wordOffset, 0);
            BoolToByte(ref dst, src.Hex, 1, 3 + wordOffset, 1);
        }
        private static void _VARIABLE_TO_STRING_PARAM_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _VARIABLE_TO_STRING_PARAM_ToByte(ref dst, ( _VARIABLE_TO_STRING_PARAM ) src.GetValue(indices), len, wordOffset);
                wordOffset += _VARIABLE_TO_STRING_PARAM_WSIZE;
            }
        }
        public static void _VARIABLE_TO_STRING_PARAM_ToByte(ref byte[] dst, _VARIABLE_TO_STRING_PARAM[] src, int len = 1, int wordOffset = 0)
        {
            _VARIABLE_TO_STRING_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _VARIABLE_TO_STRING_PARAM_ToByte(ref byte[] dst, _VARIABLE_TO_STRING_PARAM[,] src, int len = 1, int wordOffset = 0)
        {
            _VARIABLE_TO_STRING_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _VARIABLE_TO_STRING_PARAM_ToByte(ref byte[] dst, _VARIABLE_TO_STRING_PARAM[,,] src, int len = 1, int wordOffset = 0)
        {
            _VARIABLE_TO_STRING_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _VARIABLE_TO_STRING_PARAM_ToByte(ref byte[] dst, _VARIABLE_TO_STRING_PARAM[,,,] src, int len = 1, int wordOffset = 0)
        {
            _VARIABLE_TO_STRING_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _VARIABLE_TO_STRING_PARAM_ToByte(ref byte[] dst, _VARIABLE_TO_STRING_PARAM[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _VARIABLE_TO_STRING_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _VARIABLE_TO_STRING_PARAM_ToByte(ref byte[] dst, _VARIABLE_TO_STRING_PARAM[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _VARIABLE_TO_STRING_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _VARIABLE_TO_STRING_PARAM_ToByte(ref byte[] dst, _VARIABLE_TO_STRING_PARAM[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _VARIABLE_TO_STRING_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _VARIABLE_TO_STRING_PARAM_ToByte(ref byte[] dst, _VARIABLE_TO_STRING_PARAM[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _VARIABLE_TO_STRING_PARAM_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _FILE_INFO_ToByte(ref byte[] dst, _FILE_INFO src, int len = 1, int wordOffset = 0)
        {
            StringToByte(ref dst, src.FileName, 1, 0 + wordOffset, 129);
            _FILE_STATUS_ToByte(ref dst, src.FileStatus, 1, 66 + wordOffset);
        }
        private static void _FILE_INFO_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _FILE_INFO_ToByte(ref dst, ( _FILE_INFO ) src.GetValue(indices), len, wordOffset);
                wordOffset += _FILE_INFO_WSIZE;
            }
        }
        public static void _FILE_INFO_ToByte(ref byte[] dst, _FILE_INFO[] src, int len = 1, int wordOffset = 0)
        {
            _FILE_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _FILE_INFO_ToByte(ref byte[] dst, _FILE_INFO[,] src, int len = 1, int wordOffset = 0)
        {
            _FILE_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _FILE_INFO_ToByte(ref byte[] dst, _FILE_INFO[,,] src, int len = 1, int wordOffset = 0)
        {
            _FILE_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _FILE_INFO_ToByte(ref byte[] dst, _FILE_INFO[,,,] src, int len = 1, int wordOffset = 0)
        {
            _FILE_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _FILE_INFO_ToByte(ref byte[] dst, _FILE_INFO[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _FILE_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _FILE_INFO_ToByte(ref byte[] dst, _FILE_INFO[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _FILE_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _FILE_INFO_ToByte(ref byte[] dst, _FILE_INFO[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _FILE_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _FILE_INFO_ToByte(ref byte[] dst, _FILE_INFO[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _FILE_INFO_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_AXIS_REF_ToByte(ref byte[] dst, _MC_AXIS_REF src, int len = 1, int wordOffset = 0)
        {
            UshortToByte(ref dst, src.AxisNo, 1, 0 + wordOffset);
            _MC_AXIS_STATUS_ToByte(ref dst, src.Status, 1, 2 + wordOffset);
            _MC_AXIS_CMP_CODE_ToByte(ref dst, src.CmpCode, 1, 114 + wordOffset);
            _MC_AXIS_SYNC_STATUS_ToByte(ref dst, src.SyncStatus, 1, 138 + wordOffset);
            _MC_AXIS_STATUS_BIT_ToByte(ref dst, src.StatusBit, 1, 218 + wordOffset);
        }
        private static void _MC_AXIS_REF_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_AXIS_REF_ToByte(ref dst, ( _MC_AXIS_REF ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_AXIS_REF_WSIZE;
            }
        }
        public static void _MC_AXIS_REF_ToByte(ref byte[] dst, _MC_AXIS_REF[] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_REF_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_REF_ToByte(ref byte[] dst, _MC_AXIS_REF[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_REF_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_REF_ToByte(ref byte[] dst, _MC_AXIS_REF[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_REF_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_REF_ToByte(ref byte[] dst, _MC_AXIS_REF[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_REF_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_REF_ToByte(ref byte[] dst, _MC_AXIS_REF[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_REF_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_REF_ToByte(ref byte[] dst, _MC_AXIS_REF[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_REF_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_REF_ToByte(ref byte[] dst, _MC_AXIS_REF[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_REF_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_AXIS_REF_ToByte(ref byte[] dst, _MC_AXIS_REF[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_AXIS_REF_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_COMMON_CFG_ToByte(ref byte[] dst, _MC_COMMON_CFG src, int len = 1, int wordOffset = 0)
        {
            UshortToByte(ref dst, src.UnitCfg, 1, 0 + wordOffset);
            _MC_SYNC_EXT_INPUT_CFG_ToByte(ref dst, src.SyncExtInputCfg, 48, 2 + wordOffset);
        }
        private static void _MC_COMMON_CFG_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_COMMON_CFG_ToByte(ref dst, ( _MC_COMMON_CFG ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_COMMON_CFG_WSIZE;
            }
        }
        public static void _MC_COMMON_CFG_ToByte(ref byte[] dst, _MC_COMMON_CFG[] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_CFG_ToByte(ref byte[] dst, _MC_COMMON_CFG[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_CFG_ToByte(ref byte[] dst, _MC_COMMON_CFG[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_CFG_ToByte(ref byte[] dst, _MC_COMMON_CFG[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_CFG_ToByte(ref byte[] dst, _MC_COMMON_CFG[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_CFG_ToByte(ref byte[] dst, _MC_COMMON_CFG[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_CFG_ToByte(ref byte[] dst, _MC_COMMON_CFG[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_CFG_ToByte(ref byte[] dst, _MC_COMMON_CFG[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_COMMON_STATUS_ToByte(ref byte[] dst, _MC_COMMON_STATUS src, int len = 1, int wordOffset = 0)
        {
            UshortToByte(ref dst, src.UnitErrorCode, 1, 0 + wordOffset);
            UshortToByte(ref dst, src.UnitErrorDetail, 5, 1 + wordOffset);
            _MC_SYNC_CONTACT_OUTPUT_ToByte(ref dst, src.SyncContactOutput, 32, 6 + wordOffset);
            UshortToByte(ref dst, src.Reserved, 2, 38 + wordOffset);
        }
        private static void _MC_COMMON_STATUS_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_COMMON_STATUS_ToByte(ref dst, ( _MC_COMMON_STATUS ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_COMMON_STATUS_WSIZE;
            }
        }
        public static void _MC_COMMON_STATUS_ToByte(ref byte[] dst, _MC_COMMON_STATUS[] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_STATUS_ToByte(ref byte[] dst, _MC_COMMON_STATUS[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_STATUS_ToByte(ref byte[] dst, _MC_COMMON_STATUS[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_STATUS_ToByte(ref byte[] dst, _MC_COMMON_STATUS[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_STATUS_ToByte(ref byte[] dst, _MC_COMMON_STATUS[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_STATUS_ToByte(ref byte[] dst, _MC_COMMON_STATUS[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_STATUS_ToByte(ref byte[] dst, _MC_COMMON_STATUS[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_STATUS_ToByte(ref byte[] dst, _MC_COMMON_STATUS[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_STATUS_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_SYNC_CONTACT_OUTPUT_CFG_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT_CFG src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_CONTACT_OUTPUT_SUB_CFG_ToByte(ref dst, src.ConfigNo, 32, 0 + wordOffset);
        }
        private static void _MC_SYNC_CONTACT_OUTPUT_CFG_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_SYNC_CONTACT_OUTPUT_CFG_ToByte(ref dst, ( _MC_SYNC_CONTACT_OUTPUT_CFG ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_SYNC_CONTACT_OUTPUT_CFG_WSIZE;
            }
        }
        public static void _MC_SYNC_CONTACT_OUTPUT_CFG_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT_CFG[] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_CONTACT_OUTPUT_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_CONTACT_OUTPUT_CFG_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT_CFG[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_CONTACT_OUTPUT_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_CONTACT_OUTPUT_CFG_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT_CFG[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_CONTACT_OUTPUT_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_CONTACT_OUTPUT_CFG_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT_CFG[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_CONTACT_OUTPUT_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_CONTACT_OUTPUT_CFG_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT_CFG[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_CONTACT_OUTPUT_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_CONTACT_OUTPUT_CFG_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT_CFG[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_CONTACT_OUTPUT_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_CONTACT_OUTPUT_CFG_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT_CFG[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_CONTACT_OUTPUT_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_SYNC_CONTACT_OUTPUT_CFG_ToByte(ref byte[] dst, _MC_SYNC_CONTACT_OUTPUT_CFG[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_SYNC_CONTACT_OUTPUT_CFG_ToByteBase(ref dst, src, len, wordOffset);
        }

        public static void _MC_COMMON_ToByte(ref byte[] dst, _MC_COMMON src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_STATUS_ToByte(ref dst, src.Status, 1, 0 + wordOffset);
            _MC_COMMON_CMP_CODE_ToByte(ref dst, src.CmpCode, 1, 40 + wordOffset);
            _MC_COMMON_PERFORMANCE_ToByte(ref dst, src.Performance, 1, 48 + wordOffset);
            _MC_COMMON_STATUS_BIT_ToByte(ref dst, src.StatusBit, 1, 60 + wordOffset);
        }
        private static void _MC_COMMON_ToByteBase(ref byte[] dst, Array src, int len = 1, int wordOffset = 0)
        {
            int[] indices = NewIndices(src);
            int offset = wordOffset;
            for ( int i = 0; i < len; i++ )
            {
                NextIndices(src, indices);
                _MC_COMMON_ToByte(ref dst, ( _MC_COMMON ) src.GetValue(indices), len, wordOffset);
                wordOffset += _MC_COMMON_WSIZE;
            }
        }
        public static void _MC_COMMON_ToByte(ref byte[] dst, _MC_COMMON[] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_ToByte(ref byte[] dst, _MC_COMMON[,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_ToByte(ref byte[] dst, _MC_COMMON[,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_ToByte(ref byte[] dst, _MC_COMMON[,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_ToByte(ref byte[] dst, _MC_COMMON[,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_ToByte(ref byte[] dst, _MC_COMMON[,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_ToByte(ref byte[] dst, _MC_COMMON[,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_ToByteBase(ref dst, src, len, wordOffset);
        }
        public static void _MC_COMMON_ToByte(ref byte[] dst, _MC_COMMON[,,,,,,,] src, int len = 1, int wordOffset = 0)
        {
            _MC_COMMON_ToByteBase(ref dst, src, len, wordOffset);
        }

    }
}