#pragma once

//Forward Decls Begin
struct AXIS_BASE;
#ifndef AWPLC_PC_TEST
extern "C" ret_t AXIS_BASE_exec(void* pou, uint32_t size);
extern "C" ret_t AXIS_BASE_create(void* pou, uint32_t size);
extern "C" ret_t AXIS_BASE_destroy(void* pou, uint32_t size);
extern "C" ret_t AXIS_BASE_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t AXIS_BASE_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t AXIS_BASE_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t AXIS_BASE_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t AXIS_BASE_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_CAM_ID;
struct ZMC_CAMXYVA;
struct ZMC_CAMTappet;
struct ZMC_CAM_TABLE;
struct MC_CAMSWITCH_TR;
struct MC_CAMSWITCH_REF;
struct ZMC_TA;
struct MC_TA_REF;
struct ZMC_TP;
struct MC_TP_REF;
struct MC_TRACK_TR;
struct ZMC_TV;
struct MC_TV_REF;
struct TRIGGER_REF;
struct ZMC_TappetData;
struct Cia402Axis_Script_Count;
struct Cia402Axis_Script_Writing;
struct ECAT_MASTER_KPA_IO;
#ifndef AWPLC_PC_TEST
extern "C" ret_t ECAT_MASTER_KPA_IO_exec(void* pou, uint32_t size);
extern "C" ret_t ECAT_MASTER_KPA_IO_create(void* pou, uint32_t size);
extern "C" ret_t ECAT_MASTER_KPA_IO_destroy(void* pou, uint32_t size);
extern "C" ret_t ECAT_MASTER_KPA_IO_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t ECAT_MASTER_KPA_IO_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ECAT_MASTER_KPA_IO_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ECAT_MASTER_KPA_IO_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ECAT_MASTER_KPA_IO_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct ETC_CO_SdoRead;
#ifndef AWPLC_PC_TEST
extern "C" ret_t ETC_CO_SdoRead_exec(void* pou, uint32_t size);
extern "C" ret_t ETC_CO_SdoRead_create(void* pou, uint32_t size);
extern "C" ret_t ETC_CO_SdoRead_destroy(void* pou, uint32_t size);
extern "C" ret_t ETC_CO_SdoRead_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t ETC_CO_SdoRead_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ETC_CO_SdoRead_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ETC_CO_SdoRead_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ETC_CO_SdoRead_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct ETC_CO_SdoWrite;
#ifndef AWPLC_PC_TEST
extern "C" ret_t ETC_CO_SdoWrite_exec(void* pou, uint32_t size);
extern "C" ret_t ETC_CO_SdoWrite_create(void* pou, uint32_t size);
extern "C" ret_t ETC_CO_SdoWrite_destroy(void* pou, uint32_t size);
extern "C" ret_t ETC_CO_SdoWrite_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t ETC_CO_SdoWrite_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ETC_CO_SdoWrite_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ETC_CO_SdoWrite_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ETC_CO_SdoWrite_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MODBUS_MASTER_IO;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MODBUS_MASTER_IO_exec(void* pou, uint32_t size);
extern "C" ret_t MODBUS_MASTER_IO_create(void* pou, uint32_t size);
extern "C" ret_t MODBUS_MASTER_IO_destroy(void* pou, uint32_t size);
extern "C" ret_t MODBUS_MASTER_IO_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MODBUS_MASTER_IO_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MODBUS_MASTER_IO_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MODBUS_MASTER_IO_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MODBUS_MASTER_IO_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct AXIS_CIA402_IO;
#ifndef AWPLC_PC_TEST
extern "C" ret_t AXIS_CIA402_IO_exec(void* pou, uint32_t size);
extern "C" ret_t AXIS_CIA402_IO_create(void* pou, uint32_t size);
extern "C" ret_t AXIS_CIA402_IO_destroy(void* pou, uint32_t size);
extern "C" ret_t AXIS_CIA402_IO_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t AXIS_CIA402_IO_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t AXIS_CIA402_IO_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t AXIS_CIA402_IO_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t AXIS_CIA402_IO_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct AXIS_FREE_ENCODER_IO;
#ifndef AWPLC_PC_TEST
extern "C" ret_t AXIS_FREE_ENCODER_IO_exec(void* pou, uint32_t size);
extern "C" ret_t AXIS_FREE_ENCODER_IO_create(void* pou, uint32_t size);
extern "C" ret_t AXIS_FREE_ENCODER_IO_destroy(void* pou, uint32_t size);
extern "C" ret_t AXIS_FREE_ENCODER_IO_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t AXIS_FREE_ENCODER_IO_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t AXIS_FREE_ENCODER_IO_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t AXIS_FREE_ENCODER_IO_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t AXIS_FREE_ENCODER_IO_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct AXIS_VIRTUAL_IO;
#ifndef AWPLC_PC_TEST
extern "C" ret_t AXIS_VIRTUAL_IO_exec(void* pou, uint32_t size);
extern "C" ret_t AXIS_VIRTUAL_IO_create(void* pou, uint32_t size);
extern "C" ret_t AXIS_VIRTUAL_IO_destroy(void* pou, uint32_t size);
extern "C" ret_t AXIS_VIRTUAL_IO_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t AXIS_VIRTUAL_IO_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t AXIS_VIRTUAL_IO_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t AXIS_VIRTUAL_IO_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t AXIS_VIRTUAL_IO_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_AbortTrigger;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_AbortTrigger_exec(void* pou, uint32_t size);
extern "C" ret_t MC_AbortTrigger_create(void* pou, uint32_t size);
extern "C" ret_t MC_AbortTrigger_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_AbortTrigger_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_AbortTrigger_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_AbortTrigger_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_AbortTrigger_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_AbortTrigger_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_AccelerationProfile;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_AccelerationProfile_exec(void* pou, uint32_t size);
extern "C" ret_t MC_AccelerationProfile_create(void* pou, uint32_t size);
extern "C" ret_t MC_AccelerationProfile_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_AccelerationProfile_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_AccelerationProfile_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_AccelerationProfile_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_AccelerationProfile_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_AccelerationProfile_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_CamIn;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_CamIn_exec(void* pou, uint32_t size);
extern "C" ret_t MC_CamIn_create(void* pou, uint32_t size);
extern "C" ret_t MC_CamIn_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_CamIn_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_CamIn_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_CamIn_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_CamIn_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_CamIn_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_CamOut;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_CamOut_exec(void* pou, uint32_t size);
extern "C" ret_t MC_CamOut_create(void* pou, uint32_t size);
extern "C" ret_t MC_CamOut_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_CamOut_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_CamOut_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_CamOut_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_CamOut_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_CamOut_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_CamTableSelect;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_CamTableSelect_exec(void* pou, uint32_t size);
extern "C" ret_t MC_CamTableSelect_create(void* pou, uint32_t size);
extern "C" ret_t MC_CamTableSelect_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_CamTableSelect_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_CamTableSelect_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_CamTableSelect_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_CamTableSelect_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_CamTableSelect_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_DigitalCamSwitch;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_DigitalCamSwitch_exec(void* pou, uint32_t size);
extern "C" ret_t MC_DigitalCamSwitch_create(void* pou, uint32_t size);
extern "C" ret_t MC_DigitalCamSwitch_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_DigitalCamSwitch_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_DigitalCamSwitch_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_DigitalCamSwitch_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_DigitalCamSwitch_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_DigitalCamSwitch_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_GearIn;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_GearIn_exec(void* pou, uint32_t size);
extern "C" ret_t MC_GearIn_create(void* pou, uint32_t size);
extern "C" ret_t MC_GearIn_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_GearIn_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_GearIn_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_GearIn_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_GearIn_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_GearIn_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_GearInPos;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_GearInPos_exec(void* pou, uint32_t size);
extern "C" ret_t MC_GearInPos_create(void* pou, uint32_t size);
extern "C" ret_t MC_GearInPos_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_GearInPos_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_GearInPos_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_GearInPos_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_GearInPos_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_GearInPos_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_GearOut;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_GearOut_exec(void* pou, uint32_t size);
extern "C" ret_t MC_GearOut_create(void* pou, uint32_t size);
extern "C" ret_t MC_GearOut_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_GearOut_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_GearOut_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_GearOut_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_GearOut_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_GearOut_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_Halt;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_Halt_exec(void* pou, uint32_t size);
extern "C" ret_t MC_Halt_create(void* pou, uint32_t size);
extern "C" ret_t MC_Halt_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_Halt_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_Halt_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_Halt_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_Halt_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_Halt_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_Home;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_Home_exec(void* pou, uint32_t size);
extern "C" ret_t MC_Home_create(void* pou, uint32_t size);
extern "C" ret_t MC_Home_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_Home_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_Home_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_Home_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_Home_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_Home_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_Jog;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_Jog_exec(void* pou, uint32_t size);
extern "C" ret_t MC_Jog_create(void* pou, uint32_t size);
extern "C" ret_t MC_Jog_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_Jog_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_Jog_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_Jog_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_Jog_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_Jog_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_MoveAbsolute;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_MoveAbsolute_exec(void* pou, uint32_t size);
extern "C" ret_t MC_MoveAbsolute_create(void* pou, uint32_t size);
extern "C" ret_t MC_MoveAbsolute_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_MoveAbsolute_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_MoveAbsolute_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_MoveAbsolute_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_MoveAbsolute_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_MoveAbsolute_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_MoveAdditive;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_MoveAdditive_exec(void* pou, uint32_t size);
extern "C" ret_t MC_MoveAdditive_create(void* pou, uint32_t size);
extern "C" ret_t MC_MoveAdditive_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_MoveAdditive_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_MoveAdditive_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_MoveAdditive_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_MoveAdditive_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_MoveAdditive_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_MoveContinuousAbsolute;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_MoveContinuousAbsolute_exec(void* pou, uint32_t size);
extern "C" ret_t MC_MoveContinuousAbsolute_create(void* pou, uint32_t size);
extern "C" ret_t MC_MoveContinuousAbsolute_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_MoveContinuousAbsolute_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_MoveContinuousAbsolute_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_MoveContinuousAbsolute_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_MoveContinuousAbsolute_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_MoveContinuousAbsolute_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_MoveContinuousRelative;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_MoveContinuousRelative_exec(void* pou, uint32_t size);
extern "C" ret_t MC_MoveContinuousRelative_create(void* pou, uint32_t size);
extern "C" ret_t MC_MoveContinuousRelative_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_MoveContinuousRelative_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_MoveContinuousRelative_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_MoveContinuousRelative_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_MoveContinuousRelative_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_MoveContinuousRelative_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_MoveRelative;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_MoveRelative_exec(void* pou, uint32_t size);
extern "C" ret_t MC_MoveRelative_create(void* pou, uint32_t size);
extern "C" ret_t MC_MoveRelative_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_MoveRelative_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_MoveRelative_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_MoveRelative_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_MoveRelative_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_MoveRelative_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_MoveSuperImposed;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_MoveSuperImposed_exec(void* pou, uint32_t size);
extern "C" ret_t MC_MoveSuperImposed_create(void* pou, uint32_t size);
extern "C" ret_t MC_MoveSuperImposed_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_MoveSuperImposed_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_MoveSuperImposed_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_MoveSuperImposed_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_MoveSuperImposed_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_MoveSuperImposed_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_MoveVelocity;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_MoveVelocity_exec(void* pou, uint32_t size);
extern "C" ret_t MC_MoveVelocity_create(void* pou, uint32_t size);
extern "C" ret_t MC_MoveVelocity_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_MoveVelocity_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_MoveVelocity_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_MoveVelocity_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_MoveVelocity_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_MoveVelocity_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_Phasing;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_Phasing_exec(void* pou, uint32_t size);
extern "C" ret_t MC_Phasing_create(void* pou, uint32_t size);
extern "C" ret_t MC_Phasing_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_Phasing_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_Phasing_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_Phasing_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_Phasing_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_Phasing_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_PositionProfile;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_PositionProfile_exec(void* pou, uint32_t size);
extern "C" ret_t MC_PositionProfile_create(void* pou, uint32_t size);
extern "C" ret_t MC_PositionProfile_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_PositionProfile_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_PositionProfile_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_PositionProfile_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_PositionProfile_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_PositionProfile_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_Power;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_Power_exec(void* pou, uint32_t size);
extern "C" ret_t MC_Power_create(void* pou, uint32_t size);
extern "C" ret_t MC_Power_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_Power_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_Power_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_Power_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_Power_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_Power_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_ReadActualPosition;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_ReadActualPosition_exec(void* pou, uint32_t size);
extern "C" ret_t MC_ReadActualPosition_create(void* pou, uint32_t size);
extern "C" ret_t MC_ReadActualPosition_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_ReadActualPosition_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_ReadActualPosition_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadActualPosition_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadActualPosition_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadActualPosition_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_ReadActualTorque;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_ReadActualTorque_exec(void* pou, uint32_t size);
extern "C" ret_t MC_ReadActualTorque_create(void* pou, uint32_t size);
extern "C" ret_t MC_ReadActualTorque_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_ReadActualTorque_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_ReadActualTorque_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadActualTorque_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadActualTorque_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadActualTorque_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_ReadActualVelocity;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_ReadActualVelocity_exec(void* pou, uint32_t size);
extern "C" ret_t MC_ReadActualVelocity_create(void* pou, uint32_t size);
extern "C" ret_t MC_ReadActualVelocity_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_ReadActualVelocity_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_ReadActualVelocity_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadActualVelocity_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadActualVelocity_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadActualVelocity_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_ReadAxisError;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_ReadAxisError_exec(void* pou, uint32_t size);
extern "C" ret_t MC_ReadAxisError_create(void* pou, uint32_t size);
extern "C" ret_t MC_ReadAxisError_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_ReadAxisError_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_ReadAxisError_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadAxisError_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadAxisError_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadAxisError_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_ReadBoolParameter;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_ReadBoolParameter_exec(void* pou, uint32_t size);
extern "C" ret_t MC_ReadBoolParameter_create(void* pou, uint32_t size);
extern "C" ret_t MC_ReadBoolParameter_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_ReadBoolParameter_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_ReadBoolParameter_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadBoolParameter_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadBoolParameter_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadBoolParameter_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_ReadCommandPosition;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_ReadCommandPosition_exec(void* pou, uint32_t size);
extern "C" ret_t MC_ReadCommandPosition_create(void* pou, uint32_t size);
extern "C" ret_t MC_ReadCommandPosition_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_ReadCommandPosition_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_ReadCommandPosition_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadCommandPosition_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadCommandPosition_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadCommandPosition_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_ReadParameter;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_ReadParameter_exec(void* pou, uint32_t size);
extern "C" ret_t MC_ReadParameter_create(void* pou, uint32_t size);
extern "C" ret_t MC_ReadParameter_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_ReadParameter_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_ReadParameter_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadParameter_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadParameter_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadParameter_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_ReadStatus;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_ReadStatus_exec(void* pou, uint32_t size);
extern "C" ret_t MC_ReadStatus_create(void* pou, uint32_t size);
extern "C" ret_t MC_ReadStatus_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_ReadStatus_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_ReadStatus_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadStatus_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadStatus_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadStatus_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_Reset;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_Reset_exec(void* pou, uint32_t size);
extern "C" ret_t MC_Reset_create(void* pou, uint32_t size);
extern "C" ret_t MC_Reset_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_Reset_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_Reset_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_Reset_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_Reset_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_Reset_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_SetPosition;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_SetPosition_exec(void* pou, uint32_t size);
extern "C" ret_t MC_SetPosition_create(void* pou, uint32_t size);
extern "C" ret_t MC_SetPosition_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_SetPosition_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_SetPosition_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_SetPosition_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_SetPosition_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_SetPosition_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_Stop;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_Stop_exec(void* pou, uint32_t size);
extern "C" ret_t MC_Stop_create(void* pou, uint32_t size);
extern "C" ret_t MC_Stop_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_Stop_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_Stop_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_Stop_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_Stop_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_Stop_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_TouchProbe;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_TouchProbe_exec(void* pou, uint32_t size);
extern "C" ret_t MC_TouchProbe_create(void* pou, uint32_t size);
extern "C" ret_t MC_TouchProbe_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_TouchProbe_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_TouchProbe_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_TouchProbe_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_TouchProbe_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_TouchProbe_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_VelocityProfile;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_VelocityProfile_exec(void* pou, uint32_t size);
extern "C" ret_t MC_VelocityProfile_create(void* pou, uint32_t size);
extern "C" ret_t MC_VelocityProfile_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_VelocityProfile_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_VelocityProfile_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_VelocityProfile_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_VelocityProfile_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_VelocityProfile_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_WriteBoolParameter;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_WriteBoolParameter_exec(void* pou, uint32_t size);
extern "C" ret_t MC_WriteBoolParameter_create(void* pou, uint32_t size);
extern "C" ret_t MC_WriteBoolParameter_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_WriteBoolParameter_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_WriteBoolParameter_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_WriteBoolParameter_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_WriteBoolParameter_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_WriteBoolParameter_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_WriteParameter;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_WriteParameter_exec(void* pou, uint32_t size);
extern "C" ret_t MC_WriteParameter_create(void* pou, uint32_t size);
extern "C" ret_t MC_WriteParameter_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_WriteParameter_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_WriteParameter_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_WriteParameter_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_WriteParameter_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_WriteParameter_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct ZMC_FollowPosition;
#ifndef AWPLC_PC_TEST
extern "C" ret_t ZMC_FollowPosition_exec(void* pou, uint32_t size);
extern "C" ret_t ZMC_FollowPosition_create(void* pou, uint32_t size);
extern "C" ret_t ZMC_FollowPosition_destroy(void* pou, uint32_t size);
extern "C" ret_t ZMC_FollowPosition_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t ZMC_FollowPosition_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_FollowPosition_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_FollowPosition_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_FollowPosition_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct ZMC_GetTappetValue;
#ifndef AWPLC_PC_TEST
extern "C" ret_t ZMC_GetTappetValue_exec(void* pou, uint32_t size);
extern "C" ret_t ZMC_GetTappetValue_create(void* pou, uint32_t size);
extern "C" ret_t ZMC_GetTappetValue_destroy(void* pou, uint32_t size);
extern "C" ret_t ZMC_GetTappetValue_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t ZMC_GetTappetValue_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_GetTappetValue_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_GetTappetValue_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_GetTappetValue_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct ZMC_ReadCAM;
#ifndef AWPLC_PC_TEST
extern "C" ret_t ZMC_ReadCAM_exec(void* pou, uint32_t size);
extern "C" ret_t ZMC_ReadCAM_create(void* pou, uint32_t size);
extern "C" ret_t ZMC_ReadCAM_destroy(void* pou, uint32_t size);
extern "C" ret_t ZMC_ReadCAM_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t ZMC_ReadCAM_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_ReadCAM_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_ReadCAM_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_ReadCAM_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct ZMC_WriteCAM;
#ifndef AWPLC_PC_TEST
extern "C" ret_t ZMC_WriteCAM_exec(void* pou, uint32_t size);
extern "C" ret_t ZMC_WriteCAM_create(void* pou, uint32_t size);
extern "C" ret_t ZMC_WriteCAM_destroy(void* pou, uint32_t size);
extern "C" ret_t ZMC_WriteCAM_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t ZMC_WriteCAM_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_WriteCAM_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_WriteCAM_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_WriteCAM_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_ReadActualDriveValues;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_ReadActualDriveValues_exec(void* pou, uint32_t size);
extern "C" ret_t MC_ReadActualDriveValues_create(void* pou, uint32_t size);
extern "C" ret_t MC_ReadActualDriveValues_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_ReadActualDriveValues_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_ReadActualDriveValues_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadActualDriveValues_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadActualDriveValues_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadActualDriveValues_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_ReadActualValues;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_ReadActualValues_exec(void* pou, uint32_t size);
extern "C" ret_t MC_ReadActualValues_create(void* pou, uint32_t size);
extern "C" ret_t MC_ReadActualValues_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_ReadActualValues_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_ReadActualValues_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadActualValues_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadActualValues_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadActualValues_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_ReadSetDriveValues;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_ReadSetDriveValues_exec(void* pou, uint32_t size);
extern "C" ret_t MC_ReadSetDriveValues_create(void* pou, uint32_t size);
extern "C" ret_t MC_ReadSetDriveValues_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_ReadSetDriveValues_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_ReadSetDriveValues_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadSetDriveValues_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadSetDriveValues_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadSetDriveValues_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_ReadSetValues;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_ReadSetValues_exec(void* pou, uint32_t size);
extern "C" ret_t MC_ReadSetValues_create(void* pou, uint32_t size);
extern "C" ret_t MC_ReadSetValues_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_ReadSetValues_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_ReadSetValues_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadSetValues_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadSetValues_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_ReadSetValues_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct ZMC_ChangeGearingRatio;
#ifndef AWPLC_PC_TEST
extern "C" ret_t ZMC_ChangeGearingRatio_exec(void* pou, uint32_t size);
extern "C" ret_t ZMC_ChangeGearingRatio_create(void* pou, uint32_t size);
extern "C" ret_t ZMC_ChangeGearingRatio_destroy(void* pou, uint32_t size);
extern "C" ret_t ZMC_ChangeGearingRatio_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t ZMC_ChangeGearingRatio_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_ChangeGearingRatio_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_ChangeGearingRatio_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_ChangeGearingRatio_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct ZMC_CheckLimits;
#ifndef AWPLC_PC_TEST
extern "C" ret_t ZMC_CheckLimits_exec(void* pou, uint32_t size);
extern "C" ret_t ZMC_CheckLimits_create(void* pou, uint32_t size);
extern "C" ret_t ZMC_CheckLimits_destroy(void* pou, uint32_t size);
extern "C" ret_t ZMC_CheckLimits_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t ZMC_CheckLimits_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_CheckLimits_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_CheckLimits_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_CheckLimits_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct ZMC_ControlAxisByPos;
#ifndef AWPLC_PC_TEST
extern "C" ret_t ZMC_ControlAxisByPos_exec(void* pou, uint32_t size);
extern "C" ret_t ZMC_ControlAxisByPos_create(void* pou, uint32_t size);
extern "C" ret_t ZMC_ControlAxisByPos_destroy(void* pou, uint32_t size);
extern "C" ret_t ZMC_ControlAxisByPos_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t ZMC_ControlAxisByPos_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_ControlAxisByPos_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_ControlAxisByPos_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_ControlAxisByPos_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct ZMC_ControlAxisByPosVel;
#ifndef AWPLC_PC_TEST
extern "C" ret_t ZMC_ControlAxisByPosVel_exec(void* pou, uint32_t size);
extern "C" ret_t ZMC_ControlAxisByPosVel_create(void* pou, uint32_t size);
extern "C" ret_t ZMC_ControlAxisByPosVel_destroy(void* pou, uint32_t size);
extern "C" ret_t ZMC_ControlAxisByPosVel_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t ZMC_ControlAxisByPosVel_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_ControlAxisByPosVel_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_ControlAxisByPosVel_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_ControlAxisByPosVel_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct ZMC_ControlAxisByVel;
#ifndef AWPLC_PC_TEST
extern "C" ret_t ZMC_ControlAxisByVel_exec(void* pou, uint32_t size);
extern "C" ret_t ZMC_ControlAxisByVel_create(void* pou, uint32_t size);
extern "C" ret_t ZMC_ControlAxisByVel_destroy(void* pou, uint32_t size);
extern "C" ret_t ZMC_ControlAxisByVel_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t ZMC_ControlAxisByVel_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_ControlAxisByVel_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_ControlAxisByVel_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_ControlAxisByVel_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct ZMC_ReadErrorMsg;
#ifndef AWPLC_PC_TEST
extern "C" ret_t ZMC_ReadErrorMsg_exec(void* pou, uint32_t size);
extern "C" ret_t ZMC_ReadErrorMsg_create(void* pou, uint32_t size);
extern "C" ret_t ZMC_ReadErrorMsg_destroy(void* pou, uint32_t size);
extern "C" ret_t ZMC_ReadErrorMsg_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t ZMC_ReadErrorMsg_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_ReadErrorMsg_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_ReadErrorMsg_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_ReadErrorMsg_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct ZMC_ReadAxisMappingID;
#ifndef AWPLC_PC_TEST
extern "C" ret_t ZMC_ReadAxisMappingID_exec(void* pou, uint32_t size);
extern "C" ret_t ZMC_ReadAxisMappingID_create(void* pou, uint32_t size);
extern "C" ret_t ZMC_ReadAxisMappingID_destroy(void* pou, uint32_t size);
extern "C" ret_t ZMC_ReadAxisMappingID_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t ZMC_ReadAxisMappingID_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_ReadAxisMappingID_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_ReadAxisMappingID_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_ReadAxisMappingID_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct ZMC_SetMovementType;
#ifndef AWPLC_PC_TEST
extern "C" ret_t ZMC_SetMovementType_exec(void* pou, uint32_t size);
extern "C" ret_t ZMC_SetMovementType_create(void* pou, uint32_t size);
extern "C" ret_t ZMC_SetMovementType_destroy(void* pou, uint32_t size);
extern "C" ret_t ZMC_SetMovementType_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t ZMC_SetMovementType_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_SetMovementType_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_SetMovementType_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_SetMovementType_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct ZMC_SetRampType;
#ifndef AWPLC_PC_TEST
extern "C" ret_t ZMC_SetRampType_exec(void* pou, uint32_t size);
extern "C" ret_t ZMC_SetRampType_create(void* pou, uint32_t size);
extern "C" ret_t ZMC_SetRampType_destroy(void* pou, uint32_t size);
extern "C" ret_t ZMC_SetRampType_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t ZMC_SetRampType_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_SetRampType_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_SetRampType_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_SetRampType_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct ZMC_SetSoftwareLimits;
#ifndef AWPLC_PC_TEST
extern "C" ret_t ZMC_SetSoftwareLimits_exec(void* pou, uint32_t size);
extern "C" ret_t ZMC_SetSoftwareLimits_create(void* pou, uint32_t size);
extern "C" ret_t ZMC_SetSoftwareLimits_destroy(void* pou, uint32_t size);
extern "C" ret_t ZMC_SetSoftwareLimits_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t ZMC_SetSoftwareLimits_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_SetSoftwareLimits_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_SetSoftwareLimits_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t ZMC_SetSoftwareLimits_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct AXIS_GROUP_REF;
#ifndef AWPLC_PC_TEST
extern "C" ret_t AXIS_GROUP_REF_exec(void* pou, uint32_t size);
extern "C" ret_t AXIS_GROUP_REF_create(void* pou, uint32_t size);
extern "C" ret_t AXIS_GROUP_REF_destroy(void* pou, uint32_t size);
extern "C" ret_t AXIS_GROUP_REF_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t AXIS_GROUP_REF_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t AXIS_GROUP_REF_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t AXIS_GROUP_REF_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t AXIS_GROUP_REF_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MC_AddAxisToGroup;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MC_AddAxisToGroup_exec(void* pou, uint32_t size);
extern "C" ret_t MC_AddAxisToGroup_create(void* pou, uint32_t size);
extern "C" ret_t MC_AddAxisToGroup_destroy(void* pou, uint32_t size);
extern "C" ret_t MC_AddAxisToGroup_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MC_AddAxisToGroup_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_AddAxisToGroup_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_AddAxisToGroup_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MC_AddAxisToGroup_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct MODBUS_SLAVE_IO;
#ifndef AWPLC_PC_TEST
extern "C" ret_t MODBUS_SLAVE_IO_exec(void* pou, uint32_t size);
extern "C" ret_t MODBUS_SLAVE_IO_create(void* pou, uint32_t size);
extern "C" ret_t MODBUS_SLAVE_IO_destroy(void* pou, uint32_t size);
extern "C" ret_t MODBUS_SLAVE_IO_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t MODBUS_SLAVE_IO_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MODBUS_SLAVE_IO_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MODBUS_SLAVE_IO_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t MODBUS_SLAVE_IO_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct LOCAL_EQEP;
#ifndef AWPLC_PC_TEST
extern "C" ret_t LOCAL_EQEP_exec(void* pou, uint32_t size);
extern "C" ret_t LOCAL_EQEP_create(void* pou, uint32_t size);
extern "C" ret_t LOCAL_EQEP_destroy(void* pou, uint32_t size);
extern "C" ret_t LOCAL_EQEP_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t LOCAL_EQEP_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t LOCAL_EQEP_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t LOCAL_EQEP_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t LOCAL_EQEP_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct LOCAL_IO;
#ifndef AWPLC_PC_TEST
extern "C" ret_t LOCAL_IO_exec(void* pou, uint32_t size);
extern "C" ret_t LOCAL_IO_create(void* pou, uint32_t size);
extern "C" ret_t LOCAL_IO_destroy(void* pou, uint32_t size);
extern "C" ret_t LOCAL_IO_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t LOCAL_IO_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t LOCAL_IO_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t LOCAL_IO_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t LOCAL_IO_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct LOCAL_PWM;
#ifndef AWPLC_PC_TEST
extern "C" ret_t LOCAL_PWM_exec(void* pou, uint32_t size);
extern "C" ret_t LOCAL_PWM_create(void* pou, uint32_t size);
extern "C" ret_t LOCAL_PWM_destroy(void* pou, uint32_t size);
extern "C" ret_t LOCAL_PWM_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t LOCAL_PWM_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t LOCAL_PWM_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t LOCAL_PWM_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t LOCAL_PWM_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct CANOPEN_MASTER_IO;
#ifndef AWPLC_PC_TEST
extern "C" ret_t CANOPEN_MASTER_IO_exec(void* pou, uint32_t size);
extern "C" ret_t CANOPEN_MASTER_IO_create(void* pou, uint32_t size);
extern "C" ret_t CANOPEN_MASTER_IO_destroy(void* pou, uint32_t size);
extern "C" ret_t CANOPEN_MASTER_IO_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t CANOPEN_MASTER_IO_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t CANOPEN_MASTER_IO_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t CANOPEN_MASTER_IO_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t CANOPEN_MASTER_IO_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct CANOPEN_SLAVE_IO;
#ifndef AWPLC_PC_TEST
extern "C" ret_t CANOPEN_SLAVE_IO_exec(void* pou, uint32_t size);
extern "C" ret_t CANOPEN_SLAVE_IO_create(void* pou, uint32_t size);
extern "C" ret_t CANOPEN_SLAVE_IO_destroy(void* pou, uint32_t size);
extern "C" ret_t CANOPEN_SLAVE_IO_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t CANOPEN_SLAVE_IO_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t CANOPEN_SLAVE_IO_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t CANOPEN_SLAVE_IO_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t CANOPEN_SLAVE_IO_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct EIP_SLAVE_IO;
#ifndef AWPLC_PC_TEST
extern "C" ret_t EIP_SLAVE_IO_exec(void* pou, uint32_t size);
extern "C" ret_t EIP_SLAVE_IO_create(void* pou, uint32_t size);
extern "C" ret_t EIP_SLAVE_IO_destroy(void* pou, uint32_t size);
extern "C" ret_t EIP_SLAVE_IO_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t EIP_SLAVE_IO_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t EIP_SLAVE_IO_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t EIP_SLAVE_IO_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t EIP_SLAVE_IO_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
struct OPCUA_IO;
#ifndef AWPLC_PC_TEST
extern "C" ret_t OPCUA_IO_exec(void* pou, uint32_t size);
extern "C" ret_t OPCUA_IO_create(void* pou, uint32_t size);
extern "C" ret_t OPCUA_IO_destroy(void* pou, uint32_t size);
extern "C" ret_t OPCUA_IO_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2);
#else
static inline ret_t OPCUA_IO_exec(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t OPCUA_IO_create(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t OPCUA_IO_destroy(void* pou, uint32_t size) {return RET_NOT_IMPL;}
static inline ret_t OPCUA_IO_on_copy(void* pou1, uint32_t size1, void* pou2, uint32_t size2) {return RET_NOT_IMPL;}
#endif/*WITH_WASM*/
static ret_t LOCAL_IO_Local_Hardware_IO_init_(void);
static ret_t ECAT_MASTER_KPA_IO_EtherCAT_master_2_init_(void);
static ret_t MODBUS_SLAVE_IO_Modbus_slave_custom_3_init_(void);
//Forward Decls End

//Types Begin
typedef tk_object_t* TK_OBJECT;
#define TK_OBJECT_init_(p) *(p) = NULL;

typedef value_t* VALUE;
#define VALUE_init_(p) *(p) = NULL;

typedef wbuffer_t* WBUFFER;
#define WBUFFER_init_(p) *(p) = NULL;

typedef rbuffer_t* RBUFFER;
#define RBUFFER_init_(p) *(p) = NULL;

typedef date_time_t* DATE_TIME;
#define DATE_TIME_init_(p) *(p) = NULL;

typedef fs_stat_info_t* FS_STAT_INFO;
#define FS_STAT_INFO_init_(p) *(p) = NULL;

typedef fs_file_t* FS_FILE;
#define FS_FILE_init_(p) *(p) = NULL;

typedef fs_item_t* FS_ITEM;
#define FS_ITEM_init_(p) *(p) = NULL;

typedef fs_dir_t* FS_DIR;
#define FS_DIR_init_(p) *(p) = NULL;

typedef fs_t* FS;
#define FS_init_(p) *(p) = NULL;

typedef str_t* STR;
#define STR_init_(p) *(p) = NULL;

typedef wstr_t* WSTR;
#define WSTR_init_(p) *(p) = NULL;

typedef tk_iostream_t* TK_IOSTREAM;
#define TK_IOSTREAM_init_(p) *(p) = NULL;

typedef tk_istream_t* TK_ISTREAM;
#define TK_ISTREAM_init_(p) *(p) = NULL;

typedef object_default_t* OBJECT_DEFAULT;
#define OBJECT_DEFAULT_init_(p) *(p) = NULL;

typedef tk_ostream_t* TK_OSTREAM;
#define TK_OSTREAM_init_(p) *(p) = NULL;

typedef tk_istream_file_t* TK_ISTREAM_FILE;
#define TK_ISTREAM_FILE_init_(p) *(p) = NULL;

typedef tk_ostream_file_t* TK_OSTREAM_FILE;
#define TK_OSTREAM_FILE_init_(p) *(p) = NULL;

typedef tk_iostream_tcp_t* TK_IOSTREAM_TCP;
#define TK_IOSTREAM_TCP_init_(p) *(p) = NULL;

typedef tk_iostream_udp_t* TK_IOSTREAM_UDP;
#define TK_IOSTREAM_UDP_init_(p) *(p) = NULL;

typedef tk_istream_mem_t* TK_ISTREAM_MEM;
#define TK_ISTREAM_MEM_init_(p) *(p) = NULL;

typedef tk_ostream_mem_t* TK_OSTREAM_MEM;
#define TK_OSTREAM_MEM_init_(p) *(p) = NULL;

typedef tk_iostream_serial_t* TK_IOSTREAM_SERIAL;
#define TK_IOSTREAM_SERIAL_init_(p) *(p) = NULL;

typedef AXIS_BASE* AXIS_REF;
#define AXIS_REF_init_(p) *(p) = NULL;

typedef enum : IEC_WORD {
  MC_BUFFER_MODE_Aborting = 0,
  MC_BUFFER_MODE_Buffered = 1,
  MC_BUFFER_MODE_BlendingLow = 2,
  MC_BUFFER_MODE_BlendingPrevious = 3,
  MC_BUFFER_MODE_BlendingNext = 4,
  MC_BUFFER_MODE_BlendingHigh = 5
}MC_BUFFER_MODE;

#define MC_BUFFER_MODE_init_(p) *(p) = MC_BUFFER_MODE_Aborting
typedef enum : IEC_INT {
  ZMC_CAM_TYPE_POLY = 0,
  ZMC_CAM_TYPE_X = 1,
  ZMC_CAM_TYPE_XY = 2,
  ZMC_CAM_TYPE_XYVA = 3
}ZMC_CAM_TYPE;

#define ZMC_CAM_TYPE_init_(p) *(p) = ZMC_CAM_TYPE_POLY
typedef enum : IEC_INT {
  ZMC_CAMTAPPETTYPE_TAPPET_pos = 0,
  ZMC_CAMTAPPETTYPE_TAPPET_all = 1,
  ZMC_CAMTAPPETTYPE_TAPPET_neg = 2
}ZMC_CAMTAPPETTYPE;

#define ZMC_CAMTAPPETTYPE_init_(p) *(p) = ZMC_CAMTAPPETTYPE_TAPPET_pos
typedef enum : IEC_INT {
  ZMC_CAMTAPPETACTION_TAPPETACTION_on = 0,
  ZMC_CAMTAPPETACTION_TAPPETACTION_off = 1,
  ZMC_CAMTAPPETACTION_TAPPETACTION_inv = 2,
  ZMC_CAMTAPPETACTION_TAPPETACTION_time = 3
}ZMC_CAMTAPPETACTION;

#define ZMC_CAMTAPPETACTION_init_(p) *(p) = ZMC_CAMTAPPETACTION_TAPPETACTION_on
typedef ZMC_CAM_TABLE* MC_CAM_REF;
#define MC_CAM_REF_init_(p) *(p) = NULL;

typedef enum : IEC_INT {
  MC_DIRECTION_negative = -1,
  MC_DIRECTION_shortest = 0,
  MC_DIRECTION_positive = 1,
  MC_DIRECTION_current = 2,
  MC_DIRECTION_fastest = 3
}MC_DIRECTION;

#define MC_DIRECTION_init_(p) *(p) = MC_DIRECTION_negative
typedef IEC_Vector1<IEC_BOOL,1,32> MC_OUTPUT_REF;

typedef enum : IEC_INT {
  MC_STARTMODE_absolute = 0,
  MC_STARTMODE_relative = 1,
  MC_STARTMODE_ramp_in = 2,
  MC_STARTMODE_ramp_in_pos = 3,
  MC_STARTMODE_ramp_in_neg = 4
}MC_STARTMODE;

#define MC_STARTMODE_init_(p) *(p) = MC_STARTMODE_absolute
typedef enum : IEC_INT {
  MC_TAPPETMODE_tp_mode_auto = 0,
  MC_TAPPETMODE_tp_mode_demandposition = 1,
  MC_TAPPETMODE_tp_mode_actualposition = 2
}MC_TAPPETMODE;

#define MC_TAPPETMODE_init_(p) *(p) = MC_TAPPETMODE_tp_mode_auto
typedef IEC_Vector1<MC_TRACK_TR,1,32> MC_TRACK_REF;

//Types End

//Globals Begin
extern IEC_WORD gFixedPoint;
extern IEC_UDINT gTimeStamp;
extern IEC_UDINT gModbusCount;
extern IEC_UDINT gMasterNodeID;
extern IEC_BOOL gModbusScriptWriting;
extern Cia402Axis_Script_Count gCia402AxisScriptCount;
extern IEC_UDINT gCia402AxisCount;
extern IEC_BOOL gCia402AxisCountValid;
extern Cia402Axis_Script_Writing gCia402AxisScriptWriting;
extern IEC_UDINT gSlaveNodeID;
extern IEC_UDINT gAxisIndex;
extern IEC_BOOL gReadStatus_in_Enable;
extern IEC_BOOL gReadStatus_out_Valid;
extern IEC_BOOL gReadStatus_out_Busy;
extern IEC_BOOL gReadStatus_out_Error;
extern IEC_WORD gReadStatus_out_ErrorID;
extern IEC_BOOL gReadStatus_out_Disabled;
extern IEC_BOOL gReadStatus_out_ErrorStop;
extern IEC_BOOL gReadStatus_out_Stopping;
extern IEC_BOOL gReadStatus_out_Standstill;
extern IEC_BOOL gReadStatus_out_DiscreteMotion;
extern IEC_BOOL gReadStatus_out_ContinuousMotion;
extern IEC_BOOL gReadStatus_out_SynchronizedMotion;
extern IEC_BOOL gReadStatus_out_Homing;
extern IEC_BOOL gReadStatus_out_ConstantVelocity;
extern IEC_BOOL gReadStatus_out_Accelerating;
extern IEC_BOOL gReadStatus_out_Decelerating;
extern IEC_BOOL gReadStatus_out_FBErrorOccurred;
extern IEC_BOOL gPower_in_Enable;
extern IEC_BOOL gPower_in_bRegulatorOn;
extern IEC_BOOL gPower_in_bDriveStart;
extern IEC_BOOL gPower_out_Status;
extern IEC_BOOL gPower_out_bRegulatorRealState;
extern IEC_BOOL gPower_out_bDriveRealState;
extern IEC_BOOL gPower_out_Busy;
extern IEC_BOOL gPower_out_Error;
extern IEC_WORD gPower_out_ErrorID;
extern IEC_BOOL gReset_in_Execute;
extern IEC_BOOL gReset_out_Done;
extern IEC_BOOL gReset_out_Busy;
extern IEC_BOOL gReset_out_Active;
extern IEC_BOOL gReset_out_Error;
extern IEC_WORD gReset_out_ErrorID;
extern IEC_BOOL gMoveAdd_in_Execute;
extern IEC_BOOL gMoveAdd_in_Negative;
extern IEC_LREAL gMoveAdd_in_Distance;
extern IEC_LREAL gMoveAdd_in_Velocity;
extern IEC_LREAL gMoveAdd_in_Acceleration;
extern IEC_LREAL gMoveAdd_in_Deceleration;
extern IEC_LREAL gMoveAdd_in_Jerk;
extern IEC_BOOL gMoveAdd_out_Done;
extern IEC_BOOL gMoveAdd_out_Busy;
extern IEC_BOOL gMoveAdd_out_CommandAborted;
extern IEC_BOOL gMoveAdd_out_Error;
extern IEC_WORD gMoveAdd_out_ErrorID;
extern IEC_BOOL gReadAxisError_in_Enable;
extern IEC_BOOL gReadAxisError_out_Valid;
extern IEC_BOOL gReadAxisError_out_Busy;
extern IEC_BOOL gReadAxisError_out_Error;
extern IEC_WORD gReadAxisError_out_ErrorID;
extern IEC_BOOL gReadAxisError_out_AxisError;
extern IEC_DWORD gReadAxisError_out_AxisErrorID;
extern IEC_BOOL gReadAxisError_out_SWEndSwitchActive;
extern IEC_BOOL gReadSetValues_in_Enable;
extern IEC_BOOL gReadSetValues_out_Valid;
extern IEC_BOOL gReadSetValues_out_Busy;
extern IEC_BOOL gReadSetValues_out_Error;
extern IEC_WORD gReadSetValues_out_ErrorID;
extern IEC_LREAL gReadSetValues_out_Position;
extern IEC_LREAL gReadSetValues_out_Velocity;
extern IEC_LREAL gReadSetValues_out_Acceleration;
extern IEC_LREAL gReadSetValues_out_Jerk;
extern IEC_BOOL gReadActualValues_in_Enable;
extern IEC_BOOL gReadActualValues_out_Valid;
extern IEC_BOOL gReadActualValues_out_Busy;
extern IEC_BOOL gReadActualValues_out_Error;
extern IEC_WORD gReadActualValues_out_ErrorID;
extern IEC_LREAL gReadActualValues_out_Position;
extern IEC_LREAL gReadActualValues_out_Velocity;
extern IEC_LREAL gReadActualValues_out_Acceleration;
extern IEC_LREAL gReadActualValues_out_Jerk;
extern LOCAL_IO Local_Hardware_IO;
extern ECAT_MASTER_KPA_IO EtherCAT_master_2;
extern MODBUS_SLAVE_IO Modbus_slave_custom_3;
//Globals End

ret_t _plc_init(void);

#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct AXIS_BASE {
  IEC_ULINT native;
  VOID_ADR refAxisIO;

  // this param is padding for function block, sizeof : 16, dsize : 12, align : 8
  uint8_t __padding[4];

  static bool __s_has_AXIS_BASE_on_copy;
  AXIS_BASE& operator=(AXIS_BASE&& other) noexcept {
    this->deinit_();
    native = other.native;
    refAxisIO = other.refAxisIO;
    other.refAxisIO = nullptr;
    return *this;
  }
  AXIS_BASE& operator=(const AXIS_BASE& other) {
    if (__s_has_AXIS_BASE_on_copy) {
      AXIS_BASE_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      refAxisIO = other.refAxisIO;
    }
    return *this;
  }

  AXIS_BASE(AXIS_BASE&& other) noexcept {
    native = other.native;
    refAxisIO = other.refAxisIO;
    other.refAxisIO = nullptr;
  }
  AXIS_BASE(const AXIS_BASE& other) : AXIS_BASE() {
    if (__s_has_AXIS_BASE_on_copy) {
      AXIS_BASE_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      refAxisIO = other.refAxisIO;
    }
  }

  AXIS_BASE(void) {
    AXIS_BASE_create(this, sizeof(*this));
  } 
  ~AXIS_BASE(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_refAxisIO(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_refAxisIO(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<AXIS_BASE> property_list[2];
  static IEC_Property_Range property_range_list[2];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    AXIS_BASE* self = (AXIS_BASE*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      AXIS_BASE* self = (AXIS_BASE*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define AXIS_BASE_init_(p) (p)->init_() 
struct MC_CAM_ID {
#line 13 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_cam_id.st"
  IEC_BYTE* pCT;
#line 14 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_cam_id.st"
  IEC_BOOL Periodic;
#line 15 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_cam_id.st"
  IEC_BOOL MasterAbsolute;
#line 16 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_cam_id.st"
  IEC_BOOL SlaveAbsolute;
#line 17 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_cam_id.st"
  IEC_LREAL StartMaster;
#line 18 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_cam_id.st"
  IEC_LREAL EndMaster;
#line 19 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_cam_id.st"
  IEC_LREAL StartSlave;
#line 20 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_cam_id.st"
  IEC_LREAL EndSlave;
#line 21 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_cam_id.st"
  IEC_BYTE byCompatibilityMode;

  // this param is padding for struct, sizeof : 48, dsize : 41, align : 8
  uint8_t __padding[7];

  MC_CAM_ID(void) {
  } 
  ~MC_CAM_ID(void) {this->deinit_();}
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_pCT(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Periodic(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_MasterAbsolute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_SlaveAbsolute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_StartMaster(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_EndMaster(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_StartSlave(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_EndSlave(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_byCompatibilityMode(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_pCT(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Periodic(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_MasterAbsolute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_SlaveAbsolute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_StartMaster(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_EndMaster(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_StartSlave(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_EndSlave(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_byCompatibilityMode(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_CAM_ID> property_list[9];
  static IEC_Property_Range property_range_list[8];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_CAM_ID* self = (MC_CAM_ID*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_CAM_ID* self = (MC_CAM_ID*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#define MC_CAM_ID_init_(p) (p)->init_() 
struct ZMC_CAMXYVA {
#line 15 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_xyva.st"
  IEC_LREAL dX;
#line 16 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_xyva.st"
  IEC_LREAL dY;
#line 17 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_xyva.st"
  IEC_LREAL dV;
#line 18 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_xyva.st"
  IEC_LREAL dA;

  // this struct, sizeof : 32, dsize : 32, align : 8

  ZMC_CAMXYVA(void) {
  } 
  ~ZMC_CAMXYVA(void) {this->deinit_();}
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_dX(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_dY(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_dV(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_dA(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_dX(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_dY(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_dV(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_dA(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<ZMC_CAMXYVA> property_list[4];
  static IEC_Property_Range property_range_list[1];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    ZMC_CAMXYVA* self = (ZMC_CAMXYVA*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      ZMC_CAMXYVA* self = (ZMC_CAMXYVA*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#define ZMC_CAMXYVA_init_(p) (p)->init_() 
struct ZMC_CAMTappet {
#line 18 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_tappet.st"
  ZMC_CAMTAPPETTYPE ctt;
#line 19 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_tappet.st"
  ZMC_CAMTAPPETACTION cta;
#line 20 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_tappet.st"
  IEC_DWORD dwDelay;
#line 21 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_tappet.st"
  IEC_DWORD dwDuration;
#line 22 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_tappet.st"
  IEC_INT iGroupID;
#line 23 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_tappet.st"
  IEC_LREAL x;
#line 24 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_tappet.st"
  IEC_DWORD dwActive;

  // this param is padding for struct, sizeof : 32, dsize : 28, align : 8
  uint8_t __padding[4];

  ZMC_CAMTappet(void) {
  } 
  ~ZMC_CAMTappet(void) {this->deinit_();}
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_ctt(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_cta(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_dwDelay(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_dwDuration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_iGroupID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_x(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_dwActive(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_ctt(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_cta(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_dwDelay(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_dwDuration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_iGroupID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_x(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_dwActive(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<ZMC_CAMTappet> property_list[7];
  static IEC_Property_Range property_range_list[5];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    ZMC_CAMTappet* self = (ZMC_CAMTappet*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      ZMC_CAMTappet* self = (ZMC_CAMTappet*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#define ZMC_CAMTappet_init_(p) (p)->init_() 
struct ZMC_CAM_TABLE {
#line 26 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_table.st"
  IEC_WORD wCamStructID;
#line 27 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_table.st"
  ZMC_CAM_TYPE byType;
#line 28 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_table.st"
  IEC_BYTE byVarType;
#line 29 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_table.st"
  IEC_LREAL xStart;
#line 30 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_table.st"
  IEC_LREAL xEnd;
#line 31 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_table.st"
  IEC_INT nElements;
#line 32 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_table.st"
  IEC_INT nTappets;
#line 33 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_table.st"
  ZMC_CAMXYVA* pce;
#line 34 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_table.st"
  ZMC_CAMTappet* pt;
#line 35 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_table.st"
  IEC_DWORD dwTappetActiveBits;
#line 36 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_table.st"
  IEC_String<IEC_CHAR, 80> strCAMName;
#line 37 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_table.st"
  IEC_BYTE byInterpolationQuality;
#line 38 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_table.st"
  IEC_BYTE byCompatibilityMode;
#line 39 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_table.st"
  IEC_BOOL bChangedOnline;
#line 40 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_cam_table.st"
  IEC_BOOL xPartofLM;

  // this param is padding for struct, sizeof : 128, dsize : 125, align : 8
  uint8_t __padding[3];

  ZMC_CAM_TABLE(void) {
  } 
  ~ZMC_CAM_TABLE(void) {this->deinit_();}
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_wCamStructID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_byType(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_byVarType(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_xStart(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_xEnd(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_nElements(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_nTappets(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_pce(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_pt(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_dwTappetActiveBits(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_strCAMName(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_byInterpolationQuality(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_byCompatibilityMode(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bChangedOnline(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_xPartofLM(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_wCamStructID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_byType(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_byVarType(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_xStart(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_xEnd(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_nElements(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_nTappets(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_pce(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_pt(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_dwTappetActiveBits(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_strCAMName(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_byInterpolationQuality(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_byCompatibilityMode(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bChangedOnline(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_xPartofLM(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<ZMC_CAM_TABLE> property_list[15];
  static IEC_Property_Range property_range_list[12];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    ZMC_CAM_TABLE* self = (ZMC_CAM_TABLE*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      ZMC_CAM_TABLE* self = (ZMC_CAM_TABLE*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#define ZMC_CAM_TABLE_init_(p) (p)->init_() 
struct MC_CAMSWITCH_TR {
#line 14 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_cam_switch_tr.st"
  IEC_INT TrackNumber;
#line 15 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_cam_switch_tr.st"
  IEC_LREAL FirstOnPosition;
#line 16 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_cam_switch_tr.st"
  IEC_LREAL LastOnPosition;
#line 17 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_cam_switch_tr.st"
  IEC_INT AxisDirection;
#line 18 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_cam_switch_tr.st"
  IEC_INT CamSwitchMode;
#line 19 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_cam_switch_tr.st"
  IEC_TIME Duration;
#line 20 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_cam_switch_tr.st"
  IEC_BOOL bOn;
#line 21 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_cam_switch_tr.st"
  IEC_INT CounterOff;

  // this param is padding for struct, sizeof : 48, dsize : 44, align : 8
  uint8_t __padding[4];

  MC_CAMSWITCH_TR(void) {
  } 
  ~MC_CAMSWITCH_TR(void) {this->deinit_();}
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_TrackNumber(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_FirstOnPosition(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_LastOnPosition(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_AxisDirection(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CamSwitchMode(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Duration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bOn(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CounterOff(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_TrackNumber(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_FirstOnPosition(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_LastOnPosition(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_AxisDirection(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CamSwitchMode(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Duration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bOn(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CounterOff(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_CAMSWITCH_TR> property_list[8];
  static IEC_Property_Range property_range_list[7];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_CAMSWITCH_TR* self = (MC_CAMSWITCH_TR*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_CAMSWITCH_TR* self = (MC_CAMSWITCH_TR*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#define MC_CAMSWITCH_TR_init_(p) (p)->init_() 
struct MC_CAMSWITCH_REF {
#line 11 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_cam_switch_ref.st"
  IEC_BYTE NoOfSwitches;
#line 12 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_cam_switch_ref.st"
  MC_CAMSWITCH_TR* CamSwitchPtr;

  // this struct, sizeof : 8, dsize : 8, align : 4

  MC_CAMSWITCH_REF(void) {
  } 
  ~MC_CAMSWITCH_REF(void) {this->deinit_();}
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_NoOfSwitches(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CamSwitchPtr(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_NoOfSwitches(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CamSwitchPtr(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_CAMSWITCH_REF> property_list[2];
  static IEC_Property_Range property_range_list[1];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_CAMSWITCH_REF* self = (MC_CAMSWITCH_REF*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_CAMSWITCH_REF* self = (MC_CAMSWITCH_REF*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#define MC_CAMSWITCH_REF_init_(p) (p)->init_() 
#ifndef MC_OUTPUT_REF_init_
#define MC_OUTPUT_REF_init_(p) {for (int __i = 0; __i < (p)->capacity(); __i++) {auto* __init_data = (&((p)->get())) + __i; IEC_BOOL_init_(__init_data);}} 
#endif/*MC_OUTPUT_REF_init_*/
struct ZMC_TA {
#line 12 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_ta.st"
  IEC_TIME delta_time;
#line 13 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_ta.st"
  IEC_LREAL acceleration;

  // this struct, sizeof : 16, dsize : 16, align : 8

  ZMC_TA(void) {
  } 
  ~ZMC_TA(void) {this->deinit_();}
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_delta_time(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_delta_time(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<ZMC_TA> property_list[2];
  static IEC_Property_Range property_range_list[2];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    ZMC_TA* self = (ZMC_TA*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      ZMC_TA* self = (ZMC_TA*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#define ZMC_TA_init_(p) (p)->init_() 
#ifndef IEC_Vector1_ZMC_TA_1_100_init_
#define IEC_Vector1_ZMC_TA_1_100_init_(p) {for (int __i = 0; __i < (p)->capacity(); __i++) {auto* __init_data = (&((p)->get())) + __i; ZMC_TA_init_(__init_data);}} 
#endif/*IEC_Vector1_ZMC_TA_1_100_init_*/
struct MC_TA_REF {
#line 13 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_ta_ref.st"
  IEC_INT Number_of_pairs;
#line 14 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_ta_ref.st"
  IEC_BOOL IsAbsolute;
#line 15 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_ta_ref.st"
  IEC_Vector1<ZMC_TA,1,100> MC_TA_ARRAY;

  // this struct, sizeof : 1608, dsize : 1608, align : 8

  MC_TA_REF(void) {
  } 
  ~MC_TA_REF(void) {this->deinit_();}
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_Number_of_pairs(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_IsAbsolute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_MC_TA_ARRAY(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_Number_of_pairs(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_IsAbsolute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_MC_TA_ARRAY(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_TA_REF> property_list[3];
  static IEC_Property_Range property_range_list[3];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_TA_REF* self = (MC_TA_REF*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_TA_REF* self = (MC_TA_REF*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#define MC_TA_REF_init_(p) (p)->init_() 
struct ZMC_TP {
#line 12 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_tp.st"
  IEC_TIME delta_time;
#line 13 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_tp.st"
  IEC_LREAL position;

  // this struct, sizeof : 16, dsize : 16, align : 8

  ZMC_TP(void) {
  } 
  ~ZMC_TP(void) {this->deinit_();}
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_delta_time(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_position(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_delta_time(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_position(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<ZMC_TP> property_list[2];
  static IEC_Property_Range property_range_list[2];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    ZMC_TP* self = (ZMC_TP*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      ZMC_TP* self = (ZMC_TP*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#define ZMC_TP_init_(p) (p)->init_() 
#ifndef IEC_Vector1_ZMC_TP_1_100_init_
#define IEC_Vector1_ZMC_TP_1_100_init_(p) {for (int __i = 0; __i < (p)->capacity(); __i++) {auto* __init_data = (&((p)->get())) + __i; ZMC_TP_init_(__init_data);}} 
#endif/*IEC_Vector1_ZMC_TP_1_100_init_*/
struct MC_TP_REF {
#line 13 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_tp_ref.st"
  IEC_INT Number_of_pairs;
#line 14 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_tp_ref.st"
  IEC_BOOL IsAbsolute;
#line 15 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_tp_ref.st"
  IEC_Vector1<ZMC_TP,1,100> MV_TP_ARRAY;

  // this struct, sizeof : 1608, dsize : 1608, align : 8

  MC_TP_REF(void) {
  } 
  ~MC_TP_REF(void) {this->deinit_();}
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_Number_of_pairs(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_IsAbsolute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_MV_TP_ARRAY(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_Number_of_pairs(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_IsAbsolute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_MV_TP_ARRAY(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_TP_REF> property_list[3];
  static IEC_Property_Range property_range_list[3];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_TP_REF* self = (MC_TP_REF*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_TP_REF* self = (MC_TP_REF*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#define MC_TP_REF_init_(p) (p)->init_() 
#ifndef MC_TRACK_REF_init_
#define MC_TRACK_REF_init_(p) {for (int __i = 0; __i < (p)->capacity(); __i++) {auto* __init_data = (&((p)->get())) + __i; MC_TRACK_TR_init_(__init_data);}} 
#endif/*MC_TRACK_REF_init_*/
struct MC_TRACK_TR {
#line 13 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_track_tr.st"
  IEC_LREAL OnCompensation;
#line 14 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_track_tr.st"
  IEC_LREAL OffCompensation;
#line 15 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_track_tr.st"
  IEC_LREAL Hysteresis;

  // this struct, sizeof : 24, dsize : 24, align : 8

  MC_TRACK_TR(void) {
  } 
  ~MC_TRACK_TR(void) {this->deinit_();}
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_OnCompensation(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_OffCompensation(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Hysteresis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_OnCompensation(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_OffCompensation(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Hysteresis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_TRACK_TR> property_list[3];
  static IEC_Property_Range property_range_list[3];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_TRACK_TR* self = (MC_TRACK_TR*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_TRACK_TR* self = (MC_TRACK_TR*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#define MC_TRACK_TR_init_(p) (p)->init_() 
struct ZMC_TV {
#line 12 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_tv.st"
  IEC_TIME delta_time;
#line 13 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_tv.st"
  IEC_LREAL velocity;

  // this struct, sizeof : 16, dsize : 16, align : 8

  ZMC_TV(void) {
  } 
  ~ZMC_TV(void) {this->deinit_();}
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_delta_time(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_delta_time(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<ZMC_TV> property_list[2];
  static IEC_Property_Range property_range_list[2];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    ZMC_TV* self = (ZMC_TV*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      ZMC_TV* self = (ZMC_TV*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#define ZMC_TV_init_(p) (p)->init_() 
#ifndef IEC_Vector1_ZMC_TV_1_100_init_
#define IEC_Vector1_ZMC_TV_1_100_init_(p) {for (int __i = 0; __i < (p)->capacity(); __i++) {auto* __init_data = (&((p)->get())) + __i; ZMC_TV_init_(__init_data);}} 
#endif/*IEC_Vector1_ZMC_TV_1_100_init_*/
struct MC_TV_REF {
#line 13 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_tv_ref.st"
  IEC_INT Number_of_pairs;
#line 14 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_tv_ref.st"
  IEC_BOOL IsAbsolute;
#line 15 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\mc_tv_ref.st"
  IEC_Vector1<ZMC_TV,1,100> MC_TV_ARRAY;

  // this struct, sizeof : 1608, dsize : 1608, align : 8

  MC_TV_REF(void) {
  } 
  ~MC_TV_REF(void) {this->deinit_();}
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_Number_of_pairs(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_IsAbsolute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_MC_TV_ARRAY(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_Number_of_pairs(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_IsAbsolute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_MC_TV_ARRAY(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_TV_REF> property_list[3];
  static IEC_Property_Range property_range_list[3];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_TV_REF* self = (MC_TV_REF*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_TV_REF* self = (MC_TV_REF*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#define MC_TV_REF_init_(p) (p)->init_() 
struct TRIGGER_REF {
#line 13 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\trigger_ref.st"
  IEC_INT iTriggerNumber;
#line 14 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\trigger_ref.st"
  IEC_BOOL bFastLatching;
#line 15 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\trigger_ref.st"
  IEC_BOOL bInput;

  // this struct, sizeof : 4, dsize : 4, align : 2

  TRIGGER_REF(void) {
  } 
  ~TRIGGER_REF(void) {this->deinit_();}
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_iTriggerNumber(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bFastLatching(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bInput(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_iTriggerNumber(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bFastLatching(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bInput(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<TRIGGER_REF> property_list[3];
  static IEC_Property_Range property_range_list[3];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    TRIGGER_REF* self = (TRIGGER_REF*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      TRIGGER_REF* self = (TRIGGER_REF*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#define TRIGGER_REF_init_(p) (p)->init_() 
#ifndef IEC_Vector1_ZMC_CAMTappet__0_2_init_
#define IEC_Vector1_ZMC_CAMTappet__0_2_init_(p) (p)->init(NULL)
#endif/*IEC_Vector1_ZMC_CAMTappet__0_2_init_*/
struct ZMC_TappetData {
#line 14 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_tappet_data.st"
  IEC_Vector1<ZMC_CAMTappet*,0,2> pTaps;
#line 15 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_tappet_data.st"
  IEC_DWORD dwCycleTime;
#line 16 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_tappet_data.st"
  IEC_BYTE byChannels;
#line 17 "d:\\AWStudio-for-Develop-x64-2.2.0-rc.98\\extensions\\editor_script\\build_includes\\st\\aw_plc_plugin_fb_motion_ctrl\\basic\\zmc_tappet_data.st"
  IEC_BOOL bRestart;

  // this param is padding for struct, sizeof : 20, dsize : 18, align : 4
  uint8_t __padding[2];

  ZMC_TappetData(void) {
  } 
  ~ZMC_TappetData(void) {this->deinit_();}
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_pTaps(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_dwCycleTime(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_byChannels(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bRestart(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_pTaps(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_dwCycleTime(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_byChannels(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bRestart(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<ZMC_TappetData> property_list[4];
  static IEC_Property_Range property_range_list[4];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    ZMC_TappetData* self = (ZMC_TappetData*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      ZMC_TappetData* self = (ZMC_TappetData*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#define ZMC_TappetData_init_(p) (p)->init_() 
struct Cia402Axis_Script_Count {
  IEC_UDINT masterNodeID;
  IEC_BOOL isIncrease;
  IEC_BOOL Valid;
  IEC_UDINT Count;

  // this function block, sizeof : 12, dsize : 12, align : 4

  Cia402Axis_Script_Count(void) {
  } 
  ~Cia402Axis_Script_Count(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_masterNodeID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_isIncrease(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Count(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_masterNodeID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_isIncrease(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Count(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<Cia402Axis_Script_Count> property_list[4];
  static IEC_Property_Range property_range_list[3];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    Cia402Axis_Script_Count* self = (Cia402Axis_Script_Count*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      Cia402Axis_Script_Count* self = (Cia402Axis_Script_Count*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#define Cia402Axis_Script_Count_init_(p) (p)->init_() 
struct Cia402Axis_Script_Writing {
  IEC_UDINT masterNodeID;
  IEC_BOOL updateWriting;
  IEC_BOOL isWriting;
  IEC_BOOL Valid;
  IEC_BOOL Writing;

  // this function block, sizeof : 8, dsize : 8, align : 4

  Cia402Axis_Script_Writing(void) {
  } 
  ~Cia402Axis_Script_Writing(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_masterNodeID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_updateWriting(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_isWriting(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Writing(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_masterNodeID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_updateWriting(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_isWriting(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Writing(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<Cia402Axis_Script_Writing> property_list[5];
  static IEC_Property_Range property_range_list[5];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    Cia402Axis_Script_Writing* self = (Cia402Axis_Script_Writing*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      Cia402Axis_Script_Writing* self = (Cia402Axis_Script_Writing*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#define Cia402Axis_Script_Writing_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct ECAT_MASTER_KPA_IO {
  IEC_ULINT native;

  // this function block, sizeof : 8, dsize : 8, align : 8

  static bool __s_has_ECAT_MASTER_KPA_IO_on_copy;
  ECAT_MASTER_KPA_IO& operator=(ECAT_MASTER_KPA_IO&& other) noexcept {
    this->deinit_();
    native = other.native;
    return *this;
  }
  ECAT_MASTER_KPA_IO& operator=(const ECAT_MASTER_KPA_IO& other) {
    if (__s_has_ECAT_MASTER_KPA_IO_on_copy) {
      ECAT_MASTER_KPA_IO_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
    }
    return *this;
  }

  ECAT_MASTER_KPA_IO(ECAT_MASTER_KPA_IO&& other) noexcept {
    native = other.native;
  }
  ECAT_MASTER_KPA_IO(const ECAT_MASTER_KPA_IO& other) : ECAT_MASTER_KPA_IO() {
    if (__s_has_ECAT_MASTER_KPA_IO_on_copy) {
      ECAT_MASTER_KPA_IO_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
    }
  }

  ECAT_MASTER_KPA_IO(void) {
    ECAT_MASTER_KPA_IO_create(this, sizeof(*this));
  } 
  ~ECAT_MASTER_KPA_IO(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<ECAT_MASTER_KPA_IO> property_list[1];
  static IEC_Property_Range property_range_list[1];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    ECAT_MASTER_KPA_IO* self = (ECAT_MASTER_KPA_IO*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      ECAT_MASTER_KPA_IO* self = (ECAT_MASTER_KPA_IO*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define ECAT_MASTER_KPA_IO_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct ETC_CO_SdoRead {
  IEC_ULINT native;
  IEC_BOOL xExecute;
  IEC_BOOL xAbort;
  IEC_USINT usiCom;
  IEC_UINT uiDevice;
  IEC_USINT usiChannel;
  IEC_WORD wIndex;
  IEC_BYTE bySubindex;
  IEC_UDINT udiTimeOut;
  VOID_ADR pBuffer;
  IEC_UDINT szSize;
  IEC_BOOL xDone;
  IEC_BOOL xBusy;
  IEC_BOOL xError;
  IEC_DINT eError;
  IEC_UDINT udiSdoAbort;
  IEC_UDINT szDataRead;

  // this function block, sizeof : 48, dsize : 48, align : 8

  static bool __s_has_ETC_CO_SdoRead_on_copy;
  ETC_CO_SdoRead& operator=(ETC_CO_SdoRead&& other) noexcept {
    this->deinit_();
    xBusy = other.xBusy;
    xDone = other.xDone;
    eError = other.eError;
    native = other.native;
    szSize = other.szSize;
    usiCom = other.usiCom;
    wIndex = other.wIndex;
    xAbort = other.xAbort;
    xError = other.xError;
    pBuffer = other.pBuffer;
    other.pBuffer = nullptr;
    uiDevice = other.uiDevice;
    xExecute = other.xExecute;
    bySubindex = other.bySubindex;
    szDataRead = other.szDataRead;
    udiTimeOut = other.udiTimeOut;
    usiChannel = other.usiChannel;
    udiSdoAbort = other.udiSdoAbort;
    return *this;
  }
  ETC_CO_SdoRead& operator=(const ETC_CO_SdoRead& other) {
    if (__s_has_ETC_CO_SdoRead_on_copy) {
      ETC_CO_SdoRead_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      xBusy = other.xBusy;
      xDone = other.xDone;
      eError = other.eError;
      szSize = other.szSize;
      usiCom = other.usiCom;
      wIndex = other.wIndex;
      xAbort = other.xAbort;
      xError = other.xError;
      pBuffer = other.pBuffer;
      uiDevice = other.uiDevice;
      xExecute = other.xExecute;
      bySubindex = other.bySubindex;
      szDataRead = other.szDataRead;
      udiTimeOut = other.udiTimeOut;
      usiChannel = other.usiChannel;
      udiSdoAbort = other.udiSdoAbort;
    }
    return *this;
  }

  ETC_CO_SdoRead(ETC_CO_SdoRead&& other) noexcept {
    xBusy = other.xBusy;
    xDone = other.xDone;
    eError = other.eError;
    native = other.native;
    szSize = other.szSize;
    usiCom = other.usiCom;
    wIndex = other.wIndex;
    xAbort = other.xAbort;
    xError = other.xError;
    pBuffer = other.pBuffer;
    other.pBuffer = nullptr;
    uiDevice = other.uiDevice;
    xExecute = other.xExecute;
    bySubindex = other.bySubindex;
    szDataRead = other.szDataRead;
    udiTimeOut = other.udiTimeOut;
    usiChannel = other.usiChannel;
    udiSdoAbort = other.udiSdoAbort;
  }
  ETC_CO_SdoRead(const ETC_CO_SdoRead& other) : ETC_CO_SdoRead() {
    if (__s_has_ETC_CO_SdoRead_on_copy) {
      ETC_CO_SdoRead_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      xBusy = other.xBusy;
      xDone = other.xDone;
      eError = other.eError;
      szSize = other.szSize;
      usiCom = other.usiCom;
      wIndex = other.wIndex;
      xAbort = other.xAbort;
      xError = other.xError;
      pBuffer = other.pBuffer;
      uiDevice = other.uiDevice;
      xExecute = other.xExecute;
      bySubindex = other.bySubindex;
      szDataRead = other.szDataRead;
      udiTimeOut = other.udiTimeOut;
      usiChannel = other.usiChannel;
      udiSdoAbort = other.udiSdoAbort;
    }
  }

  ETC_CO_SdoRead(void) {
    ETC_CO_SdoRead_create(this, sizeof(*this));
  } 
  ~ETC_CO_SdoRead(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_xExecute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_xAbort(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_usiCom(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_uiDevice(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_usiChannel(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_wIndex(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bySubindex(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_udiTimeOut(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_pBuffer(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_szSize(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_xDone(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_xBusy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_xError(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_eError(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_udiSdoAbort(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_szDataRead(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_xExecute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_xAbort(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_usiCom(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_uiDevice(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_usiChannel(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_wIndex(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bySubindex(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_udiTimeOut(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_pBuffer(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_szSize(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_xDone(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_xBusy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_xError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_eError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_udiSdoAbort(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_szDataRead(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<ETC_CO_SdoRead> property_list[17];
  static IEC_Property_Range property_range_list[6];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    ETC_CO_SdoRead* self = (ETC_CO_SdoRead*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      ETC_CO_SdoRead* self = (ETC_CO_SdoRead*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define ETC_CO_SdoRead_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct ETC_CO_SdoWrite {
  IEC_ULINT native;
  IEC_BOOL xExecute;
  IEC_BOOL xAbort;
  IEC_USINT usiCom;
  IEC_UINT uiDevice;
  IEC_USINT usiChannel;
  IEC_WORD wIndex;
  IEC_BYTE bySubindex;
  IEC_UDINT udiTimeOut;
  VOID_ADR pBuffer;
  IEC_UDINT szSize;
  IEC_BOOL xDone;
  IEC_BOOL xBusy;
  IEC_BOOL xError;
  IEC_DINT eError;
  IEC_UDINT udiSdoAbort;
  IEC_UDINT szDataWritten;

  // this function block, sizeof : 48, dsize : 48, align : 8

  static bool __s_has_ETC_CO_SdoWrite_on_copy;
  ETC_CO_SdoWrite& operator=(ETC_CO_SdoWrite&& other) noexcept {
    this->deinit_();
    xBusy = other.xBusy;
    xDone = other.xDone;
    eError = other.eError;
    native = other.native;
    szSize = other.szSize;
    usiCom = other.usiCom;
    wIndex = other.wIndex;
    xAbort = other.xAbort;
    xError = other.xError;
    pBuffer = other.pBuffer;
    other.pBuffer = nullptr;
    uiDevice = other.uiDevice;
    xExecute = other.xExecute;
    bySubindex = other.bySubindex;
    udiTimeOut = other.udiTimeOut;
    usiChannel = other.usiChannel;
    udiSdoAbort = other.udiSdoAbort;
    szDataWritten = other.szDataWritten;
    return *this;
  }
  ETC_CO_SdoWrite& operator=(const ETC_CO_SdoWrite& other) {
    if (__s_has_ETC_CO_SdoWrite_on_copy) {
      ETC_CO_SdoWrite_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      xBusy = other.xBusy;
      xDone = other.xDone;
      eError = other.eError;
      szSize = other.szSize;
      usiCom = other.usiCom;
      wIndex = other.wIndex;
      xAbort = other.xAbort;
      xError = other.xError;
      pBuffer = other.pBuffer;
      uiDevice = other.uiDevice;
      xExecute = other.xExecute;
      bySubindex = other.bySubindex;
      udiTimeOut = other.udiTimeOut;
      usiChannel = other.usiChannel;
      udiSdoAbort = other.udiSdoAbort;
      szDataWritten = other.szDataWritten;
    }
    return *this;
  }

  ETC_CO_SdoWrite(ETC_CO_SdoWrite&& other) noexcept {
    xBusy = other.xBusy;
    xDone = other.xDone;
    eError = other.eError;
    native = other.native;
    szSize = other.szSize;
    usiCom = other.usiCom;
    wIndex = other.wIndex;
    xAbort = other.xAbort;
    xError = other.xError;
    pBuffer = other.pBuffer;
    other.pBuffer = nullptr;
    uiDevice = other.uiDevice;
    xExecute = other.xExecute;
    bySubindex = other.bySubindex;
    udiTimeOut = other.udiTimeOut;
    usiChannel = other.usiChannel;
    udiSdoAbort = other.udiSdoAbort;
    szDataWritten = other.szDataWritten;
  }
  ETC_CO_SdoWrite(const ETC_CO_SdoWrite& other) : ETC_CO_SdoWrite() {
    if (__s_has_ETC_CO_SdoWrite_on_copy) {
      ETC_CO_SdoWrite_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      xBusy = other.xBusy;
      xDone = other.xDone;
      eError = other.eError;
      szSize = other.szSize;
      usiCom = other.usiCom;
      wIndex = other.wIndex;
      xAbort = other.xAbort;
      xError = other.xError;
      pBuffer = other.pBuffer;
      uiDevice = other.uiDevice;
      xExecute = other.xExecute;
      bySubindex = other.bySubindex;
      udiTimeOut = other.udiTimeOut;
      usiChannel = other.usiChannel;
      udiSdoAbort = other.udiSdoAbort;
      szDataWritten = other.szDataWritten;
    }
  }

  ETC_CO_SdoWrite(void) {
    ETC_CO_SdoWrite_create(this, sizeof(*this));
  } 
  ~ETC_CO_SdoWrite(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_xExecute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_xAbort(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_usiCom(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_uiDevice(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_usiChannel(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_wIndex(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bySubindex(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_udiTimeOut(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_pBuffer(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_szSize(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_xDone(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_xBusy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_xError(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_eError(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_udiSdoAbort(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_szDataWritten(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_xExecute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_xAbort(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_usiCom(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_uiDevice(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_usiChannel(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_wIndex(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bySubindex(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_udiTimeOut(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_pBuffer(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_szSize(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_xDone(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_xBusy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_xError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_eError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_udiSdoAbort(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_szDataWritten(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<ETC_CO_SdoWrite> property_list[17];
  static IEC_Property_Range property_range_list[7];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    ETC_CO_SdoWrite* self = (ETC_CO_SdoWrite*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      ETC_CO_SdoWrite* self = (ETC_CO_SdoWrite*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define ETC_CO_SdoWrite_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MODBUS_MASTER_IO {
  IEC_ULINT native;
  IEC_BOOL xDone;
  IEC_BOOL xBusy;
  IEC_BOOL xError;
  IEC_INT iErrorCode;

  // this param is padding for function block, sizeof : 16, dsize : 14, align : 8
  uint8_t __padding[2];

  static bool __s_has_MODBUS_MASTER_IO_on_copy;
  MODBUS_MASTER_IO& operator=(MODBUS_MASTER_IO&& other) noexcept {
    this->deinit_();
    xBusy = other.xBusy;
    xDone = other.xDone;
    native = other.native;
    xError = other.xError;
    iErrorCode = other.iErrorCode;
    return *this;
  }
  MODBUS_MASTER_IO& operator=(const MODBUS_MASTER_IO& other) {
    if (__s_has_MODBUS_MASTER_IO_on_copy) {
      MODBUS_MASTER_IO_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      xBusy = other.xBusy;
      xDone = other.xDone;
      xError = other.xError;
      iErrorCode = other.iErrorCode;
    }
    return *this;
  }

  MODBUS_MASTER_IO(MODBUS_MASTER_IO&& other) noexcept {
    xBusy = other.xBusy;
    xDone = other.xDone;
    native = other.native;
    xError = other.xError;
    iErrorCode = other.iErrorCode;
  }
  MODBUS_MASTER_IO(const MODBUS_MASTER_IO& other) : MODBUS_MASTER_IO() {
    if (__s_has_MODBUS_MASTER_IO_on_copy) {
      MODBUS_MASTER_IO_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      xBusy = other.xBusy;
      xDone = other.xDone;
      xError = other.xError;
      iErrorCode = other.iErrorCode;
    }
  }

  MODBUS_MASTER_IO(void) {
    MODBUS_MASTER_IO_create(this, sizeof(*this));
  } 
  ~MODBUS_MASTER_IO(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_xDone(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_xBusy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_xError(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_iErrorCode(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_xDone(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_xBusy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_xError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_iErrorCode(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MODBUS_MASTER_IO> property_list[5];
  static IEC_Property_Range property_range_list[3];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MODBUS_MASTER_IO* self = (MODBUS_MASTER_IO*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MODBUS_MASTER_IO* self = (MODBUS_MASTER_IO*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MODBUS_MASTER_IO_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct AXIS_CIA402_IO {
  IEC_ULINT native;

  // this function block, sizeof : 8, dsize : 8, align : 8

  static bool __s_has_AXIS_CIA402_IO_on_copy;
  AXIS_CIA402_IO& operator=(AXIS_CIA402_IO&& other) noexcept {
    this->deinit_();
    native = other.native;
    return *this;
  }
  AXIS_CIA402_IO& operator=(const AXIS_CIA402_IO& other) {
    if (__s_has_AXIS_CIA402_IO_on_copy) {
      AXIS_CIA402_IO_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
    }
    return *this;
  }

  AXIS_CIA402_IO(AXIS_CIA402_IO&& other) noexcept {
    native = other.native;
  }
  AXIS_CIA402_IO(const AXIS_CIA402_IO& other) : AXIS_CIA402_IO() {
    if (__s_has_AXIS_CIA402_IO_on_copy) {
      AXIS_CIA402_IO_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
    }
  }

  AXIS_CIA402_IO(void) {
    AXIS_CIA402_IO_create(this, sizeof(*this));
  } 
  ~AXIS_CIA402_IO(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<AXIS_CIA402_IO> property_list[1];
  static IEC_Property_Range property_range_list[1];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    AXIS_CIA402_IO* self = (AXIS_CIA402_IO*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      AXIS_CIA402_IO* self = (AXIS_CIA402_IO*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define AXIS_CIA402_IO_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct AXIS_FREE_ENCODER_IO {
  IEC_ULINT native;

  // this function block, sizeof : 8, dsize : 8, align : 8

  static bool __s_has_AXIS_FREE_ENCODER_IO_on_copy;
  AXIS_FREE_ENCODER_IO& operator=(AXIS_FREE_ENCODER_IO&& other) noexcept {
    this->deinit_();
    native = other.native;
    return *this;
  }
  AXIS_FREE_ENCODER_IO& operator=(const AXIS_FREE_ENCODER_IO& other) {
    if (__s_has_AXIS_FREE_ENCODER_IO_on_copy) {
      AXIS_FREE_ENCODER_IO_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
    }
    return *this;
  }

  AXIS_FREE_ENCODER_IO(AXIS_FREE_ENCODER_IO&& other) noexcept {
    native = other.native;
  }
  AXIS_FREE_ENCODER_IO(const AXIS_FREE_ENCODER_IO& other) : AXIS_FREE_ENCODER_IO() {
    if (__s_has_AXIS_FREE_ENCODER_IO_on_copy) {
      AXIS_FREE_ENCODER_IO_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
    }
  }

  AXIS_FREE_ENCODER_IO(void) {
    AXIS_FREE_ENCODER_IO_create(this, sizeof(*this));
  } 
  ~AXIS_FREE_ENCODER_IO(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<AXIS_FREE_ENCODER_IO> property_list[1];
  static IEC_Property_Range property_range_list[1];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    AXIS_FREE_ENCODER_IO* self = (AXIS_FREE_ENCODER_IO*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      AXIS_FREE_ENCODER_IO* self = (AXIS_FREE_ENCODER_IO*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define AXIS_FREE_ENCODER_IO_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct AXIS_VIRTUAL_IO {
  IEC_ULINT native;

  // this function block, sizeof : 8, dsize : 8, align : 8

  static bool __s_has_AXIS_VIRTUAL_IO_on_copy;
  AXIS_VIRTUAL_IO& operator=(AXIS_VIRTUAL_IO&& other) noexcept {
    this->deinit_();
    native = other.native;
    return *this;
  }
  AXIS_VIRTUAL_IO& operator=(const AXIS_VIRTUAL_IO& other) {
    if (__s_has_AXIS_VIRTUAL_IO_on_copy) {
      AXIS_VIRTUAL_IO_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
    }
    return *this;
  }

  AXIS_VIRTUAL_IO(AXIS_VIRTUAL_IO&& other) noexcept {
    native = other.native;
  }
  AXIS_VIRTUAL_IO(const AXIS_VIRTUAL_IO& other) : AXIS_VIRTUAL_IO() {
    if (__s_has_AXIS_VIRTUAL_IO_on_copy) {
      AXIS_VIRTUAL_IO_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
    }
  }

  AXIS_VIRTUAL_IO(void) {
    AXIS_VIRTUAL_IO_create(this, sizeof(*this));
  } 
  ~AXIS_VIRTUAL_IO(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<AXIS_VIRTUAL_IO> property_list[1];
  static IEC_Property_Range property_range_list[1];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    AXIS_VIRTUAL_IO* self = (AXIS_VIRTUAL_IO*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      AXIS_VIRTUAL_IO* self = (AXIS_VIRTUAL_IO*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define AXIS_VIRTUAL_IO_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_AbortTrigger {
  IEC_ULINT native;
  AXIS_REF Axis;
  TRIGGER_REF TriggerInput;
  IEC_BOOL Execute;
  IEC_BOOL Done;
  IEC_BOOL Busy;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 24, dsize : 22, align : 8
  uint8_t __padding[2];

  static bool __s_has_MC_AbortTrigger_on_copy;
  MC_AbortTrigger& operator=(MC_AbortTrigger&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    TriggerInput = other.TriggerInput;
    return *this;
  }
  MC_AbortTrigger& operator=(const MC_AbortTrigger& other) {
    if (__s_has_MC_AbortTrigger_on_copy) {
      MC_AbortTrigger_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      TriggerInput = other.TriggerInput;
    }
    return *this;
  }

  MC_AbortTrigger(MC_AbortTrigger&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    TriggerInput = other.TriggerInput;
  }
  MC_AbortTrigger(const MC_AbortTrigger& other) : MC_AbortTrigger() {
    if (__s_has_MC_AbortTrigger_on_copy) {
      MC_AbortTrigger_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      TriggerInput = other.TriggerInput;
    }
  }

  MC_AbortTrigger(void) {
    MC_AbortTrigger_create(this, sizeof(*this));
  } 
  ~MC_AbortTrigger(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_TriggerInput(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_TriggerInput(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_AbortTrigger> property_list[8];
  static IEC_Property_Range property_range_list[5];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_AbortTrigger* self = (MC_AbortTrigger*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_AbortTrigger* self = (MC_AbortTrigger*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_AbortTrigger_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_AccelerationProfile {
  IEC_ULINT native;
  AXIS_REF Axis;
  MC_TA_REF TimeAcceleration;
  IEC_BOOL Execute;
  IEC_INT ArraySize;
  IEC_LREAL AccelerationScale;
  IEC_LREAL Offset;
  IEC_BOOL Done;
  IEC_BOOL Busy;
  IEC_BOOL CommandAbort;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 1656, dsize : 1654, align : 8
  uint8_t __padding[2];

  static bool __s_has_MC_AccelerationProfile_on_copy;
  MC_AccelerationProfile& operator=(MC_AccelerationProfile&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    Offset = other.Offset;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    ArraySize = other.ArraySize;
    CommandAbort = other.CommandAbort;
    TimeAcceleration = other.TimeAcceleration;
    AccelerationScale = other.AccelerationScale;
    return *this;
  }
  MC_AccelerationProfile& operator=(const MC_AccelerationProfile& other) {
    if (__s_has_MC_AccelerationProfile_on_copy) {
      MC_AccelerationProfile_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      Offset = other.Offset;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      ArraySize = other.ArraySize;
      CommandAbort = other.CommandAbort;
      TimeAcceleration = other.TimeAcceleration;
      AccelerationScale = other.AccelerationScale;
    }
    return *this;
  }

  MC_AccelerationProfile(MC_AccelerationProfile&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    Offset = other.Offset;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    ArraySize = other.ArraySize;
    CommandAbort = other.CommandAbort;
    TimeAcceleration = other.TimeAcceleration;
    AccelerationScale = other.AccelerationScale;
  }
  MC_AccelerationProfile(const MC_AccelerationProfile& other) : MC_AccelerationProfile() {
    if (__s_has_MC_AccelerationProfile_on_copy) {
      MC_AccelerationProfile_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      Offset = other.Offset;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      ArraySize = other.ArraySize;
      CommandAbort = other.CommandAbort;
      TimeAcceleration = other.TimeAcceleration;
      AccelerationScale = other.AccelerationScale;
    }
  }

  MC_AccelerationProfile(void) {
    MC_AccelerationProfile_create(this, sizeof(*this));
  } 
  ~MC_AccelerationProfile(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_TimeAcceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ArraySize(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_AccelerationScale(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Offset(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CommandAbort(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_TimeAcceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ArraySize(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_AccelerationScale(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Offset(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CommandAbort(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_AccelerationProfile> property_list[12];
  static IEC_Property_Range property_range_list[8];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_AccelerationProfile* self = (MC_AccelerationProfile*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_AccelerationProfile* self = (MC_AccelerationProfile*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_AccelerationProfile_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_CamIn {
  IEC_ULINT native;
  AXIS_REF Master;
  AXIS_REF Slave;
  IEC_BOOL Execute;
  IEC_LREAL MasterOffset;
  IEC_LREAL SlaveOffset;
  IEC_LREAL MasterScaling;
  IEC_LREAL SlaveScaling;
  MC_STARTMODE StartMode;
  MC_CAM_ID CamTableID;
  IEC_LREAL VelocityDiff;
  IEC_LREAL Acceleration;
  IEC_LREAL Deceleration;
  IEC_LREAL Jerk;
  IEC_LREAL TappetHysteresis;
  IEC_BOOL InSync;
  IEC_BOOL Busy;
  IEC_BOOL CommandAborted;
  IEC_BOOL Error;
  IEC_WORD ErrorID;
  IEC_BOOL EndOfProfile;
  ZMC_TappetData Tappets;

  // this param is padding for function block, sizeof : 184, dsize : 180, align : 8
  uint8_t __padding[4];

  static bool __s_has_MC_CamIn_on_copy;
  MC_CamIn& operator=(MC_CamIn&& other) noexcept {
    this->deinit_();
    Busy = other.Busy;
    Jerk = other.Jerk;
    Error = other.Error;
    Slave = other.Slave;
    other.Slave = nullptr;
    InSync = other.InSync;
    Master = other.Master;
    other.Master = nullptr;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Tappets = other.Tappets;
    StartMode = other.StartMode;
    CamTableID = other.CamTableID;
    SlaveOffset = other.SlaveOffset;
    Acceleration = other.Acceleration;
    Deceleration = other.Deceleration;
    EndOfProfile = other.EndOfProfile;
    MasterOffset = other.MasterOffset;
    SlaveScaling = other.SlaveScaling;
    VelocityDiff = other.VelocityDiff;
    MasterScaling = other.MasterScaling;
    CommandAborted = other.CommandAborted;
    TappetHysteresis = other.TappetHysteresis;
    return *this;
  }
  MC_CamIn& operator=(const MC_CamIn& other) {
    if (__s_has_MC_CamIn_on_copy) {
      MC_CamIn_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Busy = other.Busy;
      Jerk = other.Jerk;
      Error = other.Error;
      Slave = other.Slave;
      InSync = other.InSync;
      Master = other.Master;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Tappets = other.Tappets;
      StartMode = other.StartMode;
      CamTableID = other.CamTableID;
      SlaveOffset = other.SlaveOffset;
      Acceleration = other.Acceleration;
      Deceleration = other.Deceleration;
      EndOfProfile = other.EndOfProfile;
      MasterOffset = other.MasterOffset;
      SlaveScaling = other.SlaveScaling;
      VelocityDiff = other.VelocityDiff;
      MasterScaling = other.MasterScaling;
      CommandAborted = other.CommandAborted;
      TappetHysteresis = other.TappetHysteresis;
    }
    return *this;
  }

  MC_CamIn(MC_CamIn&& other) noexcept {
    Busy = other.Busy;
    Jerk = other.Jerk;
    Error = other.Error;
    Slave = other.Slave;
    other.Slave = nullptr;
    InSync = other.InSync;
    Master = other.Master;
    other.Master = nullptr;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Tappets = other.Tappets;
    StartMode = other.StartMode;
    CamTableID = other.CamTableID;
    SlaveOffset = other.SlaveOffset;
    Acceleration = other.Acceleration;
    Deceleration = other.Deceleration;
    EndOfProfile = other.EndOfProfile;
    MasterOffset = other.MasterOffset;
    SlaveScaling = other.SlaveScaling;
    VelocityDiff = other.VelocityDiff;
    MasterScaling = other.MasterScaling;
    CommandAborted = other.CommandAborted;
    TappetHysteresis = other.TappetHysteresis;
  }
  MC_CamIn(const MC_CamIn& other) : MC_CamIn() {
    if (__s_has_MC_CamIn_on_copy) {
      MC_CamIn_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Busy = other.Busy;
      Jerk = other.Jerk;
      Error = other.Error;
      Slave = other.Slave;
      InSync = other.InSync;
      Master = other.Master;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Tappets = other.Tappets;
      StartMode = other.StartMode;
      CamTableID = other.CamTableID;
      SlaveOffset = other.SlaveOffset;
      Acceleration = other.Acceleration;
      Deceleration = other.Deceleration;
      EndOfProfile = other.EndOfProfile;
      MasterOffset = other.MasterOffset;
      SlaveScaling = other.SlaveScaling;
      VelocityDiff = other.VelocityDiff;
      MasterScaling = other.MasterScaling;
      CommandAborted = other.CommandAborted;
      TappetHysteresis = other.TappetHysteresis;
    }
  }

  MC_CamIn(void) {
    MC_CamIn_create(this, sizeof(*this));
  } 
  ~MC_CamIn(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Master(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Slave(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_MasterOffset(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_SlaveOffset(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_MasterScaling(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_SlaveScaling(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_StartMode(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CamTableID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_VelocityDiff(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_TappetHysteresis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_InSync(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_EndOfProfile(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Tappets(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Master(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Slave(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_MasterOffset(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_SlaveOffset(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_MasterScaling(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_SlaveScaling(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_StartMode(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CamTableID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_VelocityDiff(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_TappetHysteresis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_InSync(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_EndOfProfile(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Tappets(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_CamIn> property_list[22];
  static IEC_Property_Range property_range_list[11];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_CamIn* self = (MC_CamIn*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_CamIn* self = (MC_CamIn*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_CamIn_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_CamOut {
  IEC_ULINT native;
  AXIS_REF Slave;
  IEC_BOOL Execute;
  IEC_BOOL Done;
  IEC_BOOL Busy;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 24, dsize : 18, align : 8
  uint8_t __padding[6];

  static bool __s_has_MC_CamOut_on_copy;
  MC_CamOut& operator=(MC_CamOut&& other) noexcept {
    this->deinit_();
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    Slave = other.Slave;
    other.Slave = nullptr;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    return *this;
  }
  MC_CamOut& operator=(const MC_CamOut& other) {
    if (__s_has_MC_CamOut_on_copy) {
      MC_CamOut_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      Slave = other.Slave;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
    }
    return *this;
  }

  MC_CamOut(MC_CamOut&& other) noexcept {
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    Slave = other.Slave;
    other.Slave = nullptr;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
  }
  MC_CamOut(const MC_CamOut& other) : MC_CamOut() {
    if (__s_has_MC_CamOut_on_copy) {
      MC_CamOut_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      Slave = other.Slave;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
    }
  }

  MC_CamOut(void) {
    MC_CamOut_create(this, sizeof(*this));
  } 
  ~MC_CamOut(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Slave(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Slave(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_CamOut> property_list[7];
  static IEC_Property_Range property_range_list[4];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_CamOut* self = (MC_CamOut*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_CamOut* self = (MC_CamOut*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_CamOut_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_CamTableSelect {
  IEC_ULINT native;
  AXIS_REF Master;
  AXIS_REF Slave;
  MC_CAM_REF CamTable;
  IEC_BOOL Execute;
  IEC_BOOL Periodic;
  IEC_BOOL MasterAbsolute;
  IEC_BOOL SlaveAbsolute;
  IEC_BOOL Done;
  IEC_BOOL Busy;
  IEC_BOOL Error;
  IEC_WORD ErrorID;
  MC_CAM_ID CamTableID;

  // this function block, sizeof : 80, dsize : 80, align : 8

  static bool __s_has_MC_CamTableSelect_on_copy;
  MC_CamTableSelect& operator=(MC_CamTableSelect&& other) noexcept {
    this->deinit_();
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    Slave = other.Slave;
    other.Slave = nullptr;
    Master = other.Master;
    other.Master = nullptr;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    CamTable = other.CamTable;
    other.CamTable = nullptr;
    Periodic = other.Periodic;
    CamTableID = other.CamTableID;
    SlaveAbsolute = other.SlaveAbsolute;
    MasterAbsolute = other.MasterAbsolute;
    return *this;
  }
  MC_CamTableSelect& operator=(const MC_CamTableSelect& other) {
    if (__s_has_MC_CamTableSelect_on_copy) {
      MC_CamTableSelect_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      Slave = other.Slave;
      Master = other.Master;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      CamTable = other.CamTable;
      Periodic = other.Periodic;
      CamTableID = other.CamTableID;
      SlaveAbsolute = other.SlaveAbsolute;
      MasterAbsolute = other.MasterAbsolute;
    }
    return *this;
  }

  MC_CamTableSelect(MC_CamTableSelect&& other) noexcept {
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    Slave = other.Slave;
    other.Slave = nullptr;
    Master = other.Master;
    other.Master = nullptr;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    CamTable = other.CamTable;
    other.CamTable = nullptr;
    Periodic = other.Periodic;
    CamTableID = other.CamTableID;
    SlaveAbsolute = other.SlaveAbsolute;
    MasterAbsolute = other.MasterAbsolute;
  }
  MC_CamTableSelect(const MC_CamTableSelect& other) : MC_CamTableSelect() {
    if (__s_has_MC_CamTableSelect_on_copy) {
      MC_CamTableSelect_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      Slave = other.Slave;
      Master = other.Master;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      CamTable = other.CamTable;
      Periodic = other.Periodic;
      CamTableID = other.CamTableID;
      SlaveAbsolute = other.SlaveAbsolute;
      MasterAbsolute = other.MasterAbsolute;
    }
  }

  MC_CamTableSelect(void) {
    MC_CamTableSelect_create(this, sizeof(*this));
  } 
  ~MC_CamTableSelect(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Master(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Slave(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CamTable(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Periodic(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_MasterAbsolute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_SlaveAbsolute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CamTableID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Master(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Slave(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CamTable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Periodic(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_MasterAbsolute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_SlaveAbsolute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CamTableID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_CamTableSelect> property_list[13];
  static IEC_Property_Range property_range_list[8];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_CamTableSelect* self = (MC_CamTableSelect*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_CamTableSelect* self = (MC_CamTableSelect*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_CamTableSelect_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_DigitalCamSwitch {
  IEC_ULINT native;
  AXIS_REF Axis;
  MC_CAMSWITCH_REF Switches;
  MC_OUTPUT_REF Outputs;
  MC_TRACK_REF TrackOptions;
  IEC_BOOL Enable;
  IEC_DWORD EnableMask;
  MC_TAPPETMODE TappetMode;
  IEC_BOOL InOperation;
  IEC_BOOL Busy;
  IEC_BOOL Error;
  IEC_WORD ErrorID;
  IEC_INT SwitchCorrupted;

  // this param is padding for function block, sizeof : 848, dsize : 842, align : 8
  uint8_t __padding[6];

  static bool __s_has_MC_DigitalCamSwitch_on_copy;
  MC_DigitalCamSwitch& operator=(MC_DigitalCamSwitch&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Error = other.Error;
    Enable = other.Enable;
    native = other.native;
    ErrorID = other.ErrorID;
    Outputs = other.Outputs;
    Switches = other.Switches;
    EnableMask = other.EnableMask;
    TappetMode = other.TappetMode;
    InOperation = other.InOperation;
    TrackOptions = other.TrackOptions;
    SwitchCorrupted = other.SwitchCorrupted;
    return *this;
  }
  MC_DigitalCamSwitch& operator=(const MC_DigitalCamSwitch& other) {
    if (__s_has_MC_DigitalCamSwitch_on_copy) {
      MC_DigitalCamSwitch_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Error = other.Error;
      Enable = other.Enable;
      ErrorID = other.ErrorID;
      Outputs = other.Outputs;
      Switches = other.Switches;
      EnableMask = other.EnableMask;
      TappetMode = other.TappetMode;
      InOperation = other.InOperation;
      TrackOptions = other.TrackOptions;
      SwitchCorrupted = other.SwitchCorrupted;
    }
    return *this;
  }

  MC_DigitalCamSwitch(MC_DigitalCamSwitch&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Error = other.Error;
    Enable = other.Enable;
    native = other.native;
    ErrorID = other.ErrorID;
    Outputs = other.Outputs;
    Switches = other.Switches;
    EnableMask = other.EnableMask;
    TappetMode = other.TappetMode;
    InOperation = other.InOperation;
    TrackOptions = other.TrackOptions;
    SwitchCorrupted = other.SwitchCorrupted;
  }
  MC_DigitalCamSwitch(const MC_DigitalCamSwitch& other) : MC_DigitalCamSwitch() {
    if (__s_has_MC_DigitalCamSwitch_on_copy) {
      MC_DigitalCamSwitch_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Error = other.Error;
      Enable = other.Enable;
      ErrorID = other.ErrorID;
      Outputs = other.Outputs;
      Switches = other.Switches;
      EnableMask = other.EnableMask;
      TappetMode = other.TappetMode;
      InOperation = other.InOperation;
      TrackOptions = other.TrackOptions;
      SwitchCorrupted = other.SwitchCorrupted;
    }
  }

  MC_DigitalCamSwitch(void) {
    MC_DigitalCamSwitch_create(this, sizeof(*this));
  } 
  ~MC_DigitalCamSwitch(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Switches(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Outputs(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_TrackOptions(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_EnableMask(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_TappetMode(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_InOperation(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_SwitchCorrupted(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Switches(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Outputs(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_TrackOptions(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_EnableMask(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_TappetMode(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_InOperation(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_SwitchCorrupted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_DigitalCamSwitch> property_list[13];
  static IEC_Property_Range property_range_list[9];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_DigitalCamSwitch* self = (MC_DigitalCamSwitch*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_DigitalCamSwitch* self = (MC_DigitalCamSwitch*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_DigitalCamSwitch_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_GearIn {
  IEC_ULINT native;
  AXIS_REF Master;
  AXIS_REF Slave;
  IEC_BOOL Execute;
  IEC_DINT RatioNumerator;
  IEC_UDINT RatioDenominator;
  IEC_LREAL Acceleration;
  IEC_LREAL Deceleration;
  IEC_LREAL Jerk;
  MC_BUFFER_MODE BufferMode;
  IEC_BOOL InGear;
  IEC_BOOL Busy;
  IEC_BOOL Active;
  IEC_BOOL CommandAborted;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 72, dsize : 66, align : 8
  uint8_t __padding[6];

  static bool __s_has_MC_GearIn_on_copy;
  MC_GearIn& operator=(MC_GearIn&& other) noexcept {
    this->deinit_();
    Busy = other.Busy;
    Jerk = other.Jerk;
    Error = other.Error;
    Slave = other.Slave;
    other.Slave = nullptr;
    Active = other.Active;
    InGear = other.InGear;
    Master = other.Master;
    other.Master = nullptr;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    BufferMode = other.BufferMode;
    Acceleration = other.Acceleration;
    Deceleration = other.Deceleration;
    CommandAborted = other.CommandAborted;
    RatioNumerator = other.RatioNumerator;
    RatioDenominator = other.RatioDenominator;
    return *this;
  }
  MC_GearIn& operator=(const MC_GearIn& other) {
    if (__s_has_MC_GearIn_on_copy) {
      MC_GearIn_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Busy = other.Busy;
      Jerk = other.Jerk;
      Error = other.Error;
      Slave = other.Slave;
      Active = other.Active;
      InGear = other.InGear;
      Master = other.Master;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      BufferMode = other.BufferMode;
      Acceleration = other.Acceleration;
      Deceleration = other.Deceleration;
      CommandAborted = other.CommandAborted;
      RatioNumerator = other.RatioNumerator;
      RatioDenominator = other.RatioDenominator;
    }
    return *this;
  }

  MC_GearIn(MC_GearIn&& other) noexcept {
    Busy = other.Busy;
    Jerk = other.Jerk;
    Error = other.Error;
    Slave = other.Slave;
    other.Slave = nullptr;
    Active = other.Active;
    InGear = other.InGear;
    Master = other.Master;
    other.Master = nullptr;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    BufferMode = other.BufferMode;
    Acceleration = other.Acceleration;
    Deceleration = other.Deceleration;
    CommandAborted = other.CommandAborted;
    RatioNumerator = other.RatioNumerator;
    RatioDenominator = other.RatioDenominator;
  }
  MC_GearIn(const MC_GearIn& other) : MC_GearIn() {
    if (__s_has_MC_GearIn_on_copy) {
      MC_GearIn_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Busy = other.Busy;
      Jerk = other.Jerk;
      Error = other.Error;
      Slave = other.Slave;
      Active = other.Active;
      InGear = other.InGear;
      Master = other.Master;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      BufferMode = other.BufferMode;
      Acceleration = other.Acceleration;
      Deceleration = other.Deceleration;
      CommandAborted = other.CommandAborted;
      RatioNumerator = other.RatioNumerator;
      RatioDenominator = other.RatioDenominator;
    }
  }

  MC_GearIn(void) {
    MC_GearIn_create(this, sizeof(*this));
  } 
  ~MC_GearIn(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Master(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Slave(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_RatioNumerator(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_RatioDenominator(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_BufferMode(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_InGear(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Active(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Master(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Slave(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_RatioNumerator(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_RatioDenominator(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_BufferMode(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_InGear(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Active(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_GearIn> property_list[16];
  static IEC_Property_Range property_range_list[8];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_GearIn* self = (MC_GearIn*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_GearIn* self = (MC_GearIn*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_GearIn_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_GearInPos {
  IEC_ULINT native;
  AXIS_REF Master;
  AXIS_REF Slave;
  IEC_BOOL Execute;
  IEC_DINT RatioNumerator;
  IEC_DINT RatioDenominator;
  IEC_LREAL MasterSyncPosition;
  IEC_LREAL SlaveSyncPosition;
  IEC_LREAL MasterStartDistance;
  MC_BUFFER_MODE BufferMode;
  IEC_BOOL AvoidReversal;
  IEC_BOOL StartSync;
  IEC_BOOL InSync;
  IEC_BOOL Busy;
  IEC_BOOL Active;
  IEC_BOOL CommandAborted;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 72, dsize : 68, align : 8
  uint8_t __padding[4];

  static bool __s_has_MC_GearInPos_on_copy;
  MC_GearInPos& operator=(MC_GearInPos&& other) noexcept {
    this->deinit_();
    Busy = other.Busy;
    Error = other.Error;
    Slave = other.Slave;
    other.Slave = nullptr;
    Active = other.Active;
    InSync = other.InSync;
    Master = other.Master;
    other.Master = nullptr;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    StartSync = other.StartSync;
    BufferMode = other.BufferMode;
    AvoidReversal = other.AvoidReversal;
    CommandAborted = other.CommandAborted;
    RatioNumerator = other.RatioNumerator;
    RatioDenominator = other.RatioDenominator;
    SlaveSyncPosition = other.SlaveSyncPosition;
    MasterSyncPosition = other.MasterSyncPosition;
    MasterStartDistance = other.MasterStartDistance;
    return *this;
  }
  MC_GearInPos& operator=(const MC_GearInPos& other) {
    if (__s_has_MC_GearInPos_on_copy) {
      MC_GearInPos_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Busy = other.Busy;
      Error = other.Error;
      Slave = other.Slave;
      Active = other.Active;
      InSync = other.InSync;
      Master = other.Master;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      StartSync = other.StartSync;
      BufferMode = other.BufferMode;
      AvoidReversal = other.AvoidReversal;
      CommandAborted = other.CommandAborted;
      RatioNumerator = other.RatioNumerator;
      RatioDenominator = other.RatioDenominator;
      SlaveSyncPosition = other.SlaveSyncPosition;
      MasterSyncPosition = other.MasterSyncPosition;
      MasterStartDistance = other.MasterStartDistance;
    }
    return *this;
  }

  MC_GearInPos(MC_GearInPos&& other) noexcept {
    Busy = other.Busy;
    Error = other.Error;
    Slave = other.Slave;
    other.Slave = nullptr;
    Active = other.Active;
    InSync = other.InSync;
    Master = other.Master;
    other.Master = nullptr;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    StartSync = other.StartSync;
    BufferMode = other.BufferMode;
    AvoidReversal = other.AvoidReversal;
    CommandAborted = other.CommandAborted;
    RatioNumerator = other.RatioNumerator;
    RatioDenominator = other.RatioDenominator;
    SlaveSyncPosition = other.SlaveSyncPosition;
    MasterSyncPosition = other.MasterSyncPosition;
    MasterStartDistance = other.MasterStartDistance;
  }
  MC_GearInPos(const MC_GearInPos& other) : MC_GearInPos() {
    if (__s_has_MC_GearInPos_on_copy) {
      MC_GearInPos_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Busy = other.Busy;
      Error = other.Error;
      Slave = other.Slave;
      Active = other.Active;
      InSync = other.InSync;
      Master = other.Master;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      StartSync = other.StartSync;
      BufferMode = other.BufferMode;
      AvoidReversal = other.AvoidReversal;
      CommandAborted = other.CommandAborted;
      RatioNumerator = other.RatioNumerator;
      RatioDenominator = other.RatioDenominator;
      SlaveSyncPosition = other.SlaveSyncPosition;
      MasterSyncPosition = other.MasterSyncPosition;
      MasterStartDistance = other.MasterStartDistance;
    }
  }

  MC_GearInPos(void) {
    MC_GearInPos_create(this, sizeof(*this));
  } 
  ~MC_GearInPos(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Master(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Slave(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_RatioNumerator(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_RatioDenominator(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_MasterSyncPosition(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_SlaveSyncPosition(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_MasterStartDistance(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_BufferMode(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_AvoidReversal(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_StartSync(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_InSync(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Active(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Master(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Slave(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_RatioNumerator(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_RatioDenominator(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_MasterSyncPosition(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_SlaveSyncPosition(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_MasterStartDistance(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_BufferMode(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_AvoidReversal(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_StartSync(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_InSync(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Active(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_GearInPos> property_list[18];
  static IEC_Property_Range property_range_list[12];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_GearInPos* self = (MC_GearInPos*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_GearInPos* self = (MC_GearInPos*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_GearInPos_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_GearOut {
  IEC_ULINT native;
  AXIS_REF Slave;
  IEC_BOOL Execute;
  IEC_BOOL Done;
  IEC_BOOL Busy;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 24, dsize : 18, align : 8
  uint8_t __padding[6];

  static bool __s_has_MC_GearOut_on_copy;
  MC_GearOut& operator=(MC_GearOut&& other) noexcept {
    this->deinit_();
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    Slave = other.Slave;
    other.Slave = nullptr;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    return *this;
  }
  MC_GearOut& operator=(const MC_GearOut& other) {
    if (__s_has_MC_GearOut_on_copy) {
      MC_GearOut_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      Slave = other.Slave;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
    }
    return *this;
  }

  MC_GearOut(MC_GearOut&& other) noexcept {
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    Slave = other.Slave;
    other.Slave = nullptr;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
  }
  MC_GearOut(const MC_GearOut& other) : MC_GearOut() {
    if (__s_has_MC_GearOut_on_copy) {
      MC_GearOut_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      Slave = other.Slave;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
    }
  }

  MC_GearOut(void) {
    MC_GearOut_create(this, sizeof(*this));
  } 
  ~MC_GearOut(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Slave(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Slave(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_GearOut> property_list[7];
  static IEC_Property_Range property_range_list[4];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_GearOut* self = (MC_GearOut*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_GearOut* self = (MC_GearOut*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_GearOut_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_Halt {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Execute;
  IEC_LREAL Deceleration;
  IEC_LREAL Jerk;
  IEC_BOOL Done;
  IEC_BOOL Busy;
  IEC_BOOL CommandAborted;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 40, dsize : 38, align : 8
  uint8_t __padding[2];

  static bool __s_has_MC_Halt_on_copy;
  MC_Halt& operator=(MC_Halt&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Jerk = other.Jerk;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Deceleration = other.Deceleration;
    CommandAborted = other.CommandAborted;
    return *this;
  }
  MC_Halt& operator=(const MC_Halt& other) {
    if (__s_has_MC_Halt_on_copy) {
      MC_Halt_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Jerk = other.Jerk;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Deceleration = other.Deceleration;
      CommandAborted = other.CommandAborted;
    }
    return *this;
  }

  MC_Halt(MC_Halt&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Jerk = other.Jerk;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Deceleration = other.Deceleration;
    CommandAborted = other.CommandAborted;
  }
  MC_Halt(const MC_Halt& other) : MC_Halt() {
    if (__s_has_MC_Halt_on_copy) {
      MC_Halt_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Jerk = other.Jerk;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Deceleration = other.Deceleration;
      CommandAborted = other.CommandAborted;
    }
  }

  MC_Halt(void) {
    MC_Halt_create(this, sizeof(*this));
  } 
  ~MC_Halt(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_Halt> property_list[10];
  static IEC_Property_Range property_range_list[6];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_Halt* self = (MC_Halt*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_Halt* self = (MC_Halt*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_Halt_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_Home {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Execute;
  IEC_LREAL Position;
  IEC_BOOL Done;
  IEC_BOOL Busy;
  IEC_BOOL CommandAborted;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 32, dsize : 30, align : 8
  uint8_t __padding[2];

  static bool __s_has_MC_Home_on_copy;
  MC_Home& operator=(MC_Home&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Position = other.Position;
    CommandAborted = other.CommandAborted;
    return *this;
  }
  MC_Home& operator=(const MC_Home& other) {
    if (__s_has_MC_Home_on_copy) {
      MC_Home_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Position = other.Position;
      CommandAborted = other.CommandAborted;
    }
    return *this;
  }

  MC_Home(MC_Home&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Position = other.Position;
    CommandAborted = other.CommandAborted;
  }
  MC_Home(const MC_Home& other) : MC_Home() {
    if (__s_has_MC_Home_on_copy) {
      MC_Home_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Position = other.Position;
      CommandAborted = other.CommandAborted;
    }
  }

  MC_Home(void) {
    MC_Home_create(this, sizeof(*this));
  } 
  ~MC_Home(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Position(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Position(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_Home> property_list[9];
  static IEC_Property_Range property_range_list[6];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_Home* self = (MC_Home*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_Home* self = (MC_Home*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_Home_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_Jog {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL JogForward;
  IEC_BOOL JogBackward;
  IEC_LREAL Velocity;
  IEC_LREAL Acceleration;
  IEC_LREAL Deceleration;
  IEC_LREAL Jerk;
  IEC_BOOL Busy;
  IEC_BOOL CommandAborted;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 56, dsize : 54, align : 8
  uint8_t __padding[2];

  static bool __s_has_MC_Jog_on_copy;
  MC_Jog& operator=(MC_Jog&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Jerk = other.Jerk;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Velocity = other.Velocity;
    JogForward = other.JogForward;
    JogBackward = other.JogBackward;
    Acceleration = other.Acceleration;
    Deceleration = other.Deceleration;
    CommandAborted = other.CommandAborted;
    return *this;
  }
  MC_Jog& operator=(const MC_Jog& other) {
    if (__s_has_MC_Jog_on_copy) {
      MC_Jog_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Jerk = other.Jerk;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Velocity = other.Velocity;
      JogForward = other.JogForward;
      JogBackward = other.JogBackward;
      Acceleration = other.Acceleration;
      Deceleration = other.Deceleration;
      CommandAborted = other.CommandAborted;
    }
    return *this;
  }

  MC_Jog(MC_Jog&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Jerk = other.Jerk;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Velocity = other.Velocity;
    JogForward = other.JogForward;
    JogBackward = other.JogBackward;
    Acceleration = other.Acceleration;
    Deceleration = other.Deceleration;
    CommandAborted = other.CommandAborted;
  }
  MC_Jog(const MC_Jog& other) : MC_Jog() {
    if (__s_has_MC_Jog_on_copy) {
      MC_Jog_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Jerk = other.Jerk;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Velocity = other.Velocity;
      JogForward = other.JogForward;
      JogBackward = other.JogBackward;
      Acceleration = other.Acceleration;
      Deceleration = other.Deceleration;
      CommandAborted = other.CommandAborted;
    }
  }

  MC_Jog(void) {
    MC_Jog_create(this, sizeof(*this));
  } 
  ~MC_Jog(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_JogForward(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_JogBackward(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_JogForward(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_JogBackward(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_Jog> property_list[12];
  static IEC_Property_Range property_range_list[9];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_Jog* self = (MC_Jog*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_Jog* self = (MC_Jog*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_Jog_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_MoveAbsolute {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Execute;
  IEC_LREAL Position;
  IEC_LREAL Velocity;
  IEC_LREAL Acceleration;
  IEC_LREAL Deceleration;
  IEC_LREAL Jerk;
  MC_DIRECTION Direction;
  MC_BUFFER_MODE BufferMode;
  IEC_BOOL Done;
  IEC_BOOL Busy;
  IEC_BOOL Active;
  IEC_BOOL CommandAborted;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 72, dsize : 68, align : 8
  uint8_t __padding[4];

  static bool __s_has_MC_MoveAbsolute_on_copy;
  MC_MoveAbsolute& operator=(MC_MoveAbsolute&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Jerk = other.Jerk;
    Error = other.Error;
    Active = other.Active;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Position = other.Position;
    Velocity = other.Velocity;
    Direction = other.Direction;
    BufferMode = other.BufferMode;
    Acceleration = other.Acceleration;
    Deceleration = other.Deceleration;
    CommandAborted = other.CommandAborted;
    return *this;
  }
  MC_MoveAbsolute& operator=(const MC_MoveAbsolute& other) {
    if (__s_has_MC_MoveAbsolute_on_copy) {
      MC_MoveAbsolute_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Jerk = other.Jerk;
      Error = other.Error;
      Active = other.Active;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Position = other.Position;
      Velocity = other.Velocity;
      Direction = other.Direction;
      BufferMode = other.BufferMode;
      Acceleration = other.Acceleration;
      Deceleration = other.Deceleration;
      CommandAborted = other.CommandAborted;
    }
    return *this;
  }

  MC_MoveAbsolute(MC_MoveAbsolute&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Jerk = other.Jerk;
    Error = other.Error;
    Active = other.Active;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Position = other.Position;
    Velocity = other.Velocity;
    Direction = other.Direction;
    BufferMode = other.BufferMode;
    Acceleration = other.Acceleration;
    Deceleration = other.Deceleration;
    CommandAborted = other.CommandAborted;
  }
  MC_MoveAbsolute(const MC_MoveAbsolute& other) : MC_MoveAbsolute() {
    if (__s_has_MC_MoveAbsolute_on_copy) {
      MC_MoveAbsolute_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Jerk = other.Jerk;
      Error = other.Error;
      Active = other.Active;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Position = other.Position;
      Velocity = other.Velocity;
      Direction = other.Direction;
      BufferMode = other.BufferMode;
      Acceleration = other.Acceleration;
      Deceleration = other.Deceleration;
      CommandAborted = other.CommandAborted;
    }
  }

  MC_MoveAbsolute(void) {
    MC_MoveAbsolute_create(this, sizeof(*this));
  } 
  ~MC_MoveAbsolute(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Position(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Direction(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_BufferMode(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Active(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Position(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Direction(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_BufferMode(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Active(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_MoveAbsolute> property_list[16];
  static IEC_Property_Range property_range_list[9];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_MoveAbsolute* self = (MC_MoveAbsolute*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_MoveAbsolute* self = (MC_MoveAbsolute*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_MoveAbsolute_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_MoveAdditive {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Execute;
  IEC_LREAL Distance;
  IEC_LREAL Velocity;
  IEC_LREAL Acceleration;
  IEC_LREAL Deceleration;
  IEC_LREAL Jerk;
  IEC_BOOL Done;
  IEC_BOOL Busy;
  IEC_BOOL CommandAborted;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 64, dsize : 62, align : 8
  uint8_t __padding[2];

  static bool __s_has_MC_MoveAdditive_on_copy;
  MC_MoveAdditive& operator=(MC_MoveAdditive&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Jerk = other.Jerk;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Distance = other.Distance;
    Velocity = other.Velocity;
    Acceleration = other.Acceleration;
    Deceleration = other.Deceleration;
    CommandAborted = other.CommandAborted;
    return *this;
  }
  MC_MoveAdditive& operator=(const MC_MoveAdditive& other) {
    if (__s_has_MC_MoveAdditive_on_copy) {
      MC_MoveAdditive_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Jerk = other.Jerk;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Distance = other.Distance;
      Velocity = other.Velocity;
      Acceleration = other.Acceleration;
      Deceleration = other.Deceleration;
      CommandAborted = other.CommandAborted;
    }
    return *this;
  }

  MC_MoveAdditive(MC_MoveAdditive&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Jerk = other.Jerk;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Distance = other.Distance;
    Velocity = other.Velocity;
    Acceleration = other.Acceleration;
    Deceleration = other.Deceleration;
    CommandAborted = other.CommandAborted;
  }
  MC_MoveAdditive(const MC_MoveAdditive& other) : MC_MoveAdditive() {
    if (__s_has_MC_MoveAdditive_on_copy) {
      MC_MoveAdditive_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Jerk = other.Jerk;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Distance = other.Distance;
      Velocity = other.Velocity;
      Acceleration = other.Acceleration;
      Deceleration = other.Deceleration;
      CommandAborted = other.CommandAborted;
    }
  }

  MC_MoveAdditive(void) {
    MC_MoveAdditive_create(this, sizeof(*this));
  } 
  ~MC_MoveAdditive(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Distance(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Distance(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_MoveAdditive> property_list[13];
  static IEC_Property_Range property_range_list[7];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_MoveAdditive* self = (MC_MoveAdditive*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_MoveAdditive* self = (MC_MoveAdditive*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_MoveAdditive_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_MoveContinuousAbsolute {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Execute;
  IEC_LREAL Position;
  IEC_LREAL Velocity;
  IEC_LREAL EndVelocity;
  IEC_WORD EndVelocityDirection;
  IEC_LREAL Acceleration;
  IEC_LREAL Deceleration;
  IEC_LREAL Jerk;
  MC_DIRECTION Direction;
  IEC_BOOL AdaptEndVelToAvoidOvershoot;
  IEC_BOOL InEndVelocity;
  IEC_BOOL Busy;
  IEC_BOOL CommandAborted;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 88, dsize : 82, align : 8
  uint8_t __padding[6];

  static bool __s_has_MC_MoveContinuousAbsolute_on_copy;
  MC_MoveContinuousAbsolute& operator=(MC_MoveContinuousAbsolute&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Jerk = other.Jerk;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Position = other.Position;
    Velocity = other.Velocity;
    Direction = other.Direction;
    EndVelocity = other.EndVelocity;
    Acceleration = other.Acceleration;
    Deceleration = other.Deceleration;
    InEndVelocity = other.InEndVelocity;
    CommandAborted = other.CommandAborted;
    EndVelocityDirection = other.EndVelocityDirection;
    AdaptEndVelToAvoidOvershoot = other.AdaptEndVelToAvoidOvershoot;
    return *this;
  }
  MC_MoveContinuousAbsolute& operator=(const MC_MoveContinuousAbsolute& other) {
    if (__s_has_MC_MoveContinuousAbsolute_on_copy) {
      MC_MoveContinuousAbsolute_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Jerk = other.Jerk;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Position = other.Position;
      Velocity = other.Velocity;
      Direction = other.Direction;
      EndVelocity = other.EndVelocity;
      Acceleration = other.Acceleration;
      Deceleration = other.Deceleration;
      InEndVelocity = other.InEndVelocity;
      CommandAborted = other.CommandAborted;
      EndVelocityDirection = other.EndVelocityDirection;
      AdaptEndVelToAvoidOvershoot = other.AdaptEndVelToAvoidOvershoot;
    }
    return *this;
  }

  MC_MoveContinuousAbsolute(MC_MoveContinuousAbsolute&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Jerk = other.Jerk;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Position = other.Position;
    Velocity = other.Velocity;
    Direction = other.Direction;
    EndVelocity = other.EndVelocity;
    Acceleration = other.Acceleration;
    Deceleration = other.Deceleration;
    InEndVelocity = other.InEndVelocity;
    CommandAborted = other.CommandAborted;
    EndVelocityDirection = other.EndVelocityDirection;
    AdaptEndVelToAvoidOvershoot = other.AdaptEndVelToAvoidOvershoot;
  }
  MC_MoveContinuousAbsolute(const MC_MoveContinuousAbsolute& other) : MC_MoveContinuousAbsolute() {
    if (__s_has_MC_MoveContinuousAbsolute_on_copy) {
      MC_MoveContinuousAbsolute_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Jerk = other.Jerk;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Position = other.Position;
      Velocity = other.Velocity;
      Direction = other.Direction;
      EndVelocity = other.EndVelocity;
      Acceleration = other.Acceleration;
      Deceleration = other.Deceleration;
      InEndVelocity = other.InEndVelocity;
      CommandAborted = other.CommandAborted;
      EndVelocityDirection = other.EndVelocityDirection;
      AdaptEndVelToAvoidOvershoot = other.AdaptEndVelToAvoidOvershoot;
    }
  }

  MC_MoveContinuousAbsolute(void) {
    MC_MoveContinuousAbsolute_create(this, sizeof(*this));
  } 
  ~MC_MoveContinuousAbsolute(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Position(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_EndVelocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_EndVelocityDirection(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Direction(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_AdaptEndVelToAvoidOvershoot(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_InEndVelocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Position(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_EndVelocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_EndVelocityDirection(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Direction(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_AdaptEndVelToAvoidOvershoot(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_InEndVelocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_MoveContinuousAbsolute> property_list[17];
  static IEC_Property_Range property_range_list[12];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_MoveContinuousAbsolute* self = (MC_MoveContinuousAbsolute*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_MoveContinuousAbsolute* self = (MC_MoveContinuousAbsolute*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_MoveContinuousAbsolute_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_MoveContinuousRelative {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Execute;
  IEC_LREAL Distance;
  IEC_LREAL Velocity;
  IEC_LREAL EndVelocity;
  IEC_WORD EndVelocityDirection;
  IEC_LREAL Acceleration;
  IEC_LREAL Deceleration;
  IEC_BOOL InEndVelocity;
  IEC_BOOL Busy;
  IEC_BOOL CommandAbort;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 72, dsize : 70, align : 8
  uint8_t __padding[2];

  static bool __s_has_MC_MoveContinuousRelative_on_copy;
  MC_MoveContinuousRelative& operator=(MC_MoveContinuousRelative&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Distance = other.Distance;
    Velocity = other.Velocity;
    EndVelocity = other.EndVelocity;
    Acceleration = other.Acceleration;
    CommandAbort = other.CommandAbort;
    Deceleration = other.Deceleration;
    InEndVelocity = other.InEndVelocity;
    EndVelocityDirection = other.EndVelocityDirection;
    return *this;
  }
  MC_MoveContinuousRelative& operator=(const MC_MoveContinuousRelative& other) {
    if (__s_has_MC_MoveContinuousRelative_on_copy) {
      MC_MoveContinuousRelative_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Distance = other.Distance;
      Velocity = other.Velocity;
      EndVelocity = other.EndVelocity;
      Acceleration = other.Acceleration;
      CommandAbort = other.CommandAbort;
      Deceleration = other.Deceleration;
      InEndVelocity = other.InEndVelocity;
      EndVelocityDirection = other.EndVelocityDirection;
    }
    return *this;
  }

  MC_MoveContinuousRelative(MC_MoveContinuousRelative&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Distance = other.Distance;
    Velocity = other.Velocity;
    EndVelocity = other.EndVelocity;
    Acceleration = other.Acceleration;
    CommandAbort = other.CommandAbort;
    Deceleration = other.Deceleration;
    InEndVelocity = other.InEndVelocity;
    EndVelocityDirection = other.EndVelocityDirection;
  }
  MC_MoveContinuousRelative(const MC_MoveContinuousRelative& other) : MC_MoveContinuousRelative() {
    if (__s_has_MC_MoveContinuousRelative_on_copy) {
      MC_MoveContinuousRelative_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Distance = other.Distance;
      Velocity = other.Velocity;
      EndVelocity = other.EndVelocity;
      Acceleration = other.Acceleration;
      CommandAbort = other.CommandAbort;
      Deceleration = other.Deceleration;
      InEndVelocity = other.InEndVelocity;
      EndVelocityDirection = other.EndVelocityDirection;
    }
  }

  MC_MoveContinuousRelative(void) {
    MC_MoveContinuousRelative_create(this, sizeof(*this));
  } 
  ~MC_MoveContinuousRelative(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Distance(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_EndVelocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_EndVelocityDirection(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_InEndVelocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CommandAbort(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Distance(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_EndVelocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_EndVelocityDirection(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_InEndVelocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CommandAbort(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_MoveContinuousRelative> property_list[14];
  static IEC_Property_Range property_range_list[9];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_MoveContinuousRelative* self = (MC_MoveContinuousRelative*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_MoveContinuousRelative* self = (MC_MoveContinuousRelative*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_MoveContinuousRelative_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_MoveRelative {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Execute;
  IEC_LREAL Distance;
  IEC_LREAL Velocity;
  IEC_LREAL Acceleration;
  IEC_LREAL Deceleration;
  IEC_LREAL Jerk;
  MC_BUFFER_MODE BufferMode;
  IEC_BOOL Done;
  IEC_BOOL Busy;
  IEC_BOOL Active;
  IEC_BOOL CommandAborted;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 72, dsize : 66, align : 8
  uint8_t __padding[6];

  static bool __s_has_MC_MoveRelative_on_copy;
  MC_MoveRelative& operator=(MC_MoveRelative&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Jerk = other.Jerk;
    Error = other.Error;
    Active = other.Active;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Distance = other.Distance;
    Velocity = other.Velocity;
    BufferMode = other.BufferMode;
    Acceleration = other.Acceleration;
    Deceleration = other.Deceleration;
    CommandAborted = other.CommandAborted;
    return *this;
  }
  MC_MoveRelative& operator=(const MC_MoveRelative& other) {
    if (__s_has_MC_MoveRelative_on_copy) {
      MC_MoveRelative_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Jerk = other.Jerk;
      Error = other.Error;
      Active = other.Active;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Distance = other.Distance;
      Velocity = other.Velocity;
      BufferMode = other.BufferMode;
      Acceleration = other.Acceleration;
      Deceleration = other.Deceleration;
      CommandAborted = other.CommandAborted;
    }
    return *this;
  }

  MC_MoveRelative(MC_MoveRelative&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Jerk = other.Jerk;
    Error = other.Error;
    Active = other.Active;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Distance = other.Distance;
    Velocity = other.Velocity;
    BufferMode = other.BufferMode;
    Acceleration = other.Acceleration;
    Deceleration = other.Deceleration;
    CommandAborted = other.CommandAborted;
  }
  MC_MoveRelative(const MC_MoveRelative& other) : MC_MoveRelative() {
    if (__s_has_MC_MoveRelative_on_copy) {
      MC_MoveRelative_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Jerk = other.Jerk;
      Error = other.Error;
      Active = other.Active;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Distance = other.Distance;
      Velocity = other.Velocity;
      BufferMode = other.BufferMode;
      Acceleration = other.Acceleration;
      Deceleration = other.Deceleration;
      CommandAborted = other.CommandAborted;
    }
  }

  MC_MoveRelative(void) {
    MC_MoveRelative_create(this, sizeof(*this));
  } 
  ~MC_MoveRelative(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Distance(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_BufferMode(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Active(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Distance(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_BufferMode(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Active(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_MoveRelative> property_list[15];
  static IEC_Property_Range property_range_list[8];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_MoveRelative* self = (MC_MoveRelative*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_MoveRelative* self = (MC_MoveRelative*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_MoveRelative_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_MoveSuperImposed {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Execute;
  IEC_LREAL Distance;
  IEC_LREAL VelocityDiff;
  IEC_LREAL Acceleration;
  IEC_LREAL Deceleration;
  IEC_LREAL Jerk;
  IEC_BOOL Done;
  IEC_BOOL Busy;
  IEC_BOOL CommandAborted;
  IEC_BOOL Error;
  IEC_WORD ErrorID;
  IEC_LREAL SuperImposedVelocity;
  IEC_LREAL SuperImposedAcceleration;

  // this function block, sizeof : 80, dsize : 80, align : 8

  static bool __s_has_MC_MoveSuperImposed_on_copy;
  MC_MoveSuperImposed& operator=(MC_MoveSuperImposed&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Jerk = other.Jerk;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Distance = other.Distance;
    Acceleration = other.Acceleration;
    Deceleration = other.Deceleration;
    VelocityDiff = other.VelocityDiff;
    CommandAborted = other.CommandAborted;
    SuperImposedVelocity = other.SuperImposedVelocity;
    SuperImposedAcceleration = other.SuperImposedAcceleration;
    return *this;
  }
  MC_MoveSuperImposed& operator=(const MC_MoveSuperImposed& other) {
    if (__s_has_MC_MoveSuperImposed_on_copy) {
      MC_MoveSuperImposed_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Jerk = other.Jerk;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Distance = other.Distance;
      Acceleration = other.Acceleration;
      Deceleration = other.Deceleration;
      VelocityDiff = other.VelocityDiff;
      CommandAborted = other.CommandAborted;
      SuperImposedVelocity = other.SuperImposedVelocity;
      SuperImposedAcceleration = other.SuperImposedAcceleration;
    }
    return *this;
  }

  MC_MoveSuperImposed(MC_MoveSuperImposed&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Jerk = other.Jerk;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Distance = other.Distance;
    Acceleration = other.Acceleration;
    Deceleration = other.Deceleration;
    VelocityDiff = other.VelocityDiff;
    CommandAborted = other.CommandAborted;
    SuperImposedVelocity = other.SuperImposedVelocity;
    SuperImposedAcceleration = other.SuperImposedAcceleration;
  }
  MC_MoveSuperImposed(const MC_MoveSuperImposed& other) : MC_MoveSuperImposed() {
    if (__s_has_MC_MoveSuperImposed_on_copy) {
      MC_MoveSuperImposed_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Jerk = other.Jerk;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Distance = other.Distance;
      Acceleration = other.Acceleration;
      Deceleration = other.Deceleration;
      VelocityDiff = other.VelocityDiff;
      CommandAborted = other.CommandAborted;
      SuperImposedVelocity = other.SuperImposedVelocity;
      SuperImposedAcceleration = other.SuperImposedAcceleration;
    }
  }

  MC_MoveSuperImposed(void) {
    MC_MoveSuperImposed_create(this, sizeof(*this));
  } 
  ~MC_MoveSuperImposed(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Distance(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_VelocityDiff(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_SuperImposedVelocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_SuperImposedAcceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Distance(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_VelocityDiff(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_SuperImposedVelocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_SuperImposedAcceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_MoveSuperImposed> property_list[15];
  static IEC_Property_Range property_range_list[9];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_MoveSuperImposed* self = (MC_MoveSuperImposed*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_MoveSuperImposed* self = (MC_MoveSuperImposed*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_MoveSuperImposed_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_MoveVelocity {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Execute;
  IEC_LREAL Velocity;
  IEC_LREAL Acceleration;
  IEC_LREAL Deceleration;
  IEC_LREAL Jerk;
  MC_DIRECTION Direction;
  MC_BUFFER_MODE BufferMode;
  IEC_BOOL InVelocity;
  IEC_BOOL Busy;
  IEC_BOOL Active;
  IEC_BOOL CommandAborted;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 64, dsize : 60, align : 8
  uint8_t __padding[4];

  static bool __s_has_MC_MoveVelocity_on_copy;
  MC_MoveVelocity& operator=(MC_MoveVelocity&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Jerk = other.Jerk;
    Error = other.Error;
    Active = other.Active;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Velocity = other.Velocity;
    Direction = other.Direction;
    BufferMode = other.BufferMode;
    InVelocity = other.InVelocity;
    Acceleration = other.Acceleration;
    Deceleration = other.Deceleration;
    CommandAborted = other.CommandAborted;
    return *this;
  }
  MC_MoveVelocity& operator=(const MC_MoveVelocity& other) {
    if (__s_has_MC_MoveVelocity_on_copy) {
      MC_MoveVelocity_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Jerk = other.Jerk;
      Error = other.Error;
      Active = other.Active;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Velocity = other.Velocity;
      Direction = other.Direction;
      BufferMode = other.BufferMode;
      InVelocity = other.InVelocity;
      Acceleration = other.Acceleration;
      Deceleration = other.Deceleration;
      CommandAborted = other.CommandAborted;
    }
    return *this;
  }

  MC_MoveVelocity(MC_MoveVelocity&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Jerk = other.Jerk;
    Error = other.Error;
    Active = other.Active;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Velocity = other.Velocity;
    Direction = other.Direction;
    BufferMode = other.BufferMode;
    InVelocity = other.InVelocity;
    Acceleration = other.Acceleration;
    Deceleration = other.Deceleration;
    CommandAborted = other.CommandAborted;
  }
  MC_MoveVelocity(const MC_MoveVelocity& other) : MC_MoveVelocity() {
    if (__s_has_MC_MoveVelocity_on_copy) {
      MC_MoveVelocity_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Jerk = other.Jerk;
      Error = other.Error;
      Active = other.Active;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Velocity = other.Velocity;
      Direction = other.Direction;
      BufferMode = other.BufferMode;
      InVelocity = other.InVelocity;
      Acceleration = other.Acceleration;
      Deceleration = other.Deceleration;
      CommandAborted = other.CommandAborted;
    }
  }

  MC_MoveVelocity(void) {
    MC_MoveVelocity_create(this, sizeof(*this));
  } 
  ~MC_MoveVelocity(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Direction(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_BufferMode(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_InVelocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Active(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Direction(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_BufferMode(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_InVelocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Active(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_MoveVelocity> property_list[15];
  static IEC_Property_Range property_range_list[9];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_MoveVelocity* self = (MC_MoveVelocity*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_MoveVelocity* self = (MC_MoveVelocity*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_MoveVelocity_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_Phasing {
  IEC_ULINT native;
  AXIS_REF Master;
  AXIS_REF Slave;
  IEC_BOOL Execute;
  IEC_LREAL PhaseShift;
  IEC_LREAL Velocity;
  IEC_LREAL Acceleration;
  IEC_LREAL Deceleration;
  IEC_LREAL Jerk;
  IEC_BOOL Done;
  IEC_BOOL Busy;
  IEC_BOOL CommandAborted;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 72, dsize : 70, align : 8
  uint8_t __padding[2];

  static bool __s_has_MC_Phasing_on_copy;
  MC_Phasing& operator=(MC_Phasing&& other) noexcept {
    this->deinit_();
    Busy = other.Busy;
    Done = other.Done;
    Jerk = other.Jerk;
    Error = other.Error;
    Slave = other.Slave;
    other.Slave = nullptr;
    Master = other.Master;
    other.Master = nullptr;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Velocity = other.Velocity;
    PhaseShift = other.PhaseShift;
    Acceleration = other.Acceleration;
    Deceleration = other.Deceleration;
    CommandAborted = other.CommandAborted;
    return *this;
  }
  MC_Phasing& operator=(const MC_Phasing& other) {
    if (__s_has_MC_Phasing_on_copy) {
      MC_Phasing_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Busy = other.Busy;
      Done = other.Done;
      Jerk = other.Jerk;
      Error = other.Error;
      Slave = other.Slave;
      Master = other.Master;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Velocity = other.Velocity;
      PhaseShift = other.PhaseShift;
      Acceleration = other.Acceleration;
      Deceleration = other.Deceleration;
      CommandAborted = other.CommandAborted;
    }
    return *this;
  }

  MC_Phasing(MC_Phasing&& other) noexcept {
    Busy = other.Busy;
    Done = other.Done;
    Jerk = other.Jerk;
    Error = other.Error;
    Slave = other.Slave;
    other.Slave = nullptr;
    Master = other.Master;
    other.Master = nullptr;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Velocity = other.Velocity;
    PhaseShift = other.PhaseShift;
    Acceleration = other.Acceleration;
    Deceleration = other.Deceleration;
    CommandAborted = other.CommandAborted;
  }
  MC_Phasing(const MC_Phasing& other) : MC_Phasing() {
    if (__s_has_MC_Phasing_on_copy) {
      MC_Phasing_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Busy = other.Busy;
      Done = other.Done;
      Jerk = other.Jerk;
      Error = other.Error;
      Slave = other.Slave;
      Master = other.Master;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Velocity = other.Velocity;
      PhaseShift = other.PhaseShift;
      Acceleration = other.Acceleration;
      Deceleration = other.Deceleration;
      CommandAborted = other.CommandAborted;
    }
  }

  MC_Phasing(void) {
    MC_Phasing_create(this, sizeof(*this));
  } 
  ~MC_Phasing(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Master(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Slave(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_PhaseShift(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Master(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Slave(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_PhaseShift(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_Phasing> property_list[14];
  static IEC_Property_Range property_range_list[8];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_Phasing* self = (MC_Phasing*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_Phasing* self = (MC_Phasing*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_Phasing_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_PositionProfile {
  IEC_ULINT native;
  AXIS_REF Axis;
  MC_TP_REF TimePosition;
  IEC_BOOL Execute;
  IEC_INT ArraySize;
  IEC_LREAL PositionScale;
  IEC_LREAL Offset;
  IEC_BOOL Done;
  IEC_BOOL Busy;
  IEC_BOOL CommandAborted;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 1656, dsize : 1654, align : 8
  uint8_t __padding[2];

  static bool __s_has_MC_PositionProfile_on_copy;
  MC_PositionProfile& operator=(MC_PositionProfile&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    Offset = other.Offset;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    ArraySize = other.ArraySize;
    TimePosition = other.TimePosition;
    PositionScale = other.PositionScale;
    CommandAborted = other.CommandAborted;
    return *this;
  }
  MC_PositionProfile& operator=(const MC_PositionProfile& other) {
    if (__s_has_MC_PositionProfile_on_copy) {
      MC_PositionProfile_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      Offset = other.Offset;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      ArraySize = other.ArraySize;
      TimePosition = other.TimePosition;
      PositionScale = other.PositionScale;
      CommandAborted = other.CommandAborted;
    }
    return *this;
  }

  MC_PositionProfile(MC_PositionProfile&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    Offset = other.Offset;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    ArraySize = other.ArraySize;
    TimePosition = other.TimePosition;
    PositionScale = other.PositionScale;
    CommandAborted = other.CommandAborted;
  }
  MC_PositionProfile(const MC_PositionProfile& other) : MC_PositionProfile() {
    if (__s_has_MC_PositionProfile_on_copy) {
      MC_PositionProfile_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      Offset = other.Offset;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      ArraySize = other.ArraySize;
      TimePosition = other.TimePosition;
      PositionScale = other.PositionScale;
      CommandAborted = other.CommandAborted;
    }
  }

  MC_PositionProfile(void) {
    MC_PositionProfile_create(this, sizeof(*this));
  } 
  ~MC_PositionProfile(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_TimePosition(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ArraySize(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_PositionScale(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Offset(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_TimePosition(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ArraySize(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_PositionScale(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Offset(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_PositionProfile> property_list[12];
  static IEC_Property_Range property_range_list[8];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_PositionProfile* self = (MC_PositionProfile*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_PositionProfile* self = (MC_PositionProfile*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_PositionProfile_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_Power {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Enable;
  IEC_BOOL bRegulatorOn;
  IEC_BOOL bDriveStart;
  IEC_BOOL Status;
  IEC_BOOL bRegulatorRealState;
  IEC_BOOL bDriveRealState;
  IEC_BOOL Busy;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 24, dsize : 22, align : 8
  uint8_t __padding[2];

  static bool __s_has_MC_Power_on_copy;
  MC_Power& operator=(MC_Power&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Error = other.Error;
    Enable = other.Enable;
    Status = other.Status;
    native = other.native;
    ErrorID = other.ErrorID;
    bDriveStart = other.bDriveStart;
    bRegulatorOn = other.bRegulatorOn;
    bDriveRealState = other.bDriveRealState;
    bRegulatorRealState = other.bRegulatorRealState;
    return *this;
  }
  MC_Power& operator=(const MC_Power& other) {
    if (__s_has_MC_Power_on_copy) {
      MC_Power_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Error = other.Error;
      Enable = other.Enable;
      Status = other.Status;
      ErrorID = other.ErrorID;
      bDriveStart = other.bDriveStart;
      bRegulatorOn = other.bRegulatorOn;
      bDriveRealState = other.bDriveRealState;
      bRegulatorRealState = other.bRegulatorRealState;
    }
    return *this;
  }

  MC_Power(MC_Power&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Error = other.Error;
    Enable = other.Enable;
    Status = other.Status;
    native = other.native;
    ErrorID = other.ErrorID;
    bDriveStart = other.bDriveStart;
    bRegulatorOn = other.bRegulatorOn;
    bDriveRealState = other.bDriveRealState;
    bRegulatorRealState = other.bRegulatorRealState;
  }
  MC_Power(const MC_Power& other) : MC_Power() {
    if (__s_has_MC_Power_on_copy) {
      MC_Power_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Error = other.Error;
      Enable = other.Enable;
      Status = other.Status;
      ErrorID = other.ErrorID;
      bDriveStart = other.bDriveStart;
      bRegulatorOn = other.bRegulatorOn;
      bDriveRealState = other.bDriveRealState;
      bRegulatorRealState = other.bRegulatorRealState;
    }
  }

  MC_Power(void) {
    MC_Power_create(this, sizeof(*this));
  } 
  ~MC_Power(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bRegulatorOn(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bDriveStart(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Status(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bRegulatorRealState(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bDriveRealState(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bRegulatorOn(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bDriveStart(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Status(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bRegulatorRealState(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bDriveRealState(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_Power> property_list[11];
  static IEC_Property_Range property_range_list[8];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_Power* self = (MC_Power*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_Power* self = (MC_Power*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_Power_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_ReadActualPosition {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Enable;
  IEC_BOOL Valid;
  IEC_BOOL Busy;
  IEC_BOOL Error;
  IEC_WORD ErrorID;
  IEC_LREAL Position;

  // this function block, sizeof : 32, dsize : 32, align : 8

  static bool __s_has_MC_ReadActualPosition_on_copy;
  MC_ReadActualPosition& operator=(MC_ReadActualPosition&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Error = other.Error;
    Valid = other.Valid;
    Enable = other.Enable;
    native = other.native;
    ErrorID = other.ErrorID;
    Position = other.Position;
    return *this;
  }
  MC_ReadActualPosition& operator=(const MC_ReadActualPosition& other) {
    if (__s_has_MC_ReadActualPosition_on_copy) {
      MC_ReadActualPosition_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Error = other.Error;
      Valid = other.Valid;
      Enable = other.Enable;
      ErrorID = other.ErrorID;
      Position = other.Position;
    }
    return *this;
  }

  MC_ReadActualPosition(MC_ReadActualPosition&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Error = other.Error;
    Valid = other.Valid;
    Enable = other.Enable;
    native = other.native;
    ErrorID = other.ErrorID;
    Position = other.Position;
  }
  MC_ReadActualPosition(const MC_ReadActualPosition& other) : MC_ReadActualPosition() {
    if (__s_has_MC_ReadActualPosition_on_copy) {
      MC_ReadActualPosition_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Error = other.Error;
      Valid = other.Valid;
      Enable = other.Enable;
      ErrorID = other.ErrorID;
      Position = other.Position;
    }
  }

  MC_ReadActualPosition(void) {
    MC_ReadActualPosition_create(this, sizeof(*this));
  } 
  ~MC_ReadActualPosition(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Position(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Position(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_ReadActualPosition> property_list[8];
  static IEC_Property_Range property_range_list[5];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_ReadActualPosition* self = (MC_ReadActualPosition*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_ReadActualPosition* self = (MC_ReadActualPosition*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_ReadActualPosition_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_ReadActualTorque {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Enable;
  IEC_BOOL Valid;
  IEC_BOOL Busy;
  IEC_BOOL Error;
  IEC_WORD ErrorID;
  IEC_LREAL Torque;

  // this function block, sizeof : 32, dsize : 32, align : 8

  static bool __s_has_MC_ReadActualTorque_on_copy;
  MC_ReadActualTorque& operator=(MC_ReadActualTorque&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Error = other.Error;
    Valid = other.Valid;
    Enable = other.Enable;
    Torque = other.Torque;
    native = other.native;
    ErrorID = other.ErrorID;
    return *this;
  }
  MC_ReadActualTorque& operator=(const MC_ReadActualTorque& other) {
    if (__s_has_MC_ReadActualTorque_on_copy) {
      MC_ReadActualTorque_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Error = other.Error;
      Valid = other.Valid;
      Enable = other.Enable;
      Torque = other.Torque;
      ErrorID = other.ErrorID;
    }
    return *this;
  }

  MC_ReadActualTorque(MC_ReadActualTorque&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Error = other.Error;
    Valid = other.Valid;
    Enable = other.Enable;
    Torque = other.Torque;
    native = other.native;
    ErrorID = other.ErrorID;
  }
  MC_ReadActualTorque(const MC_ReadActualTorque& other) : MC_ReadActualTorque() {
    if (__s_has_MC_ReadActualTorque_on_copy) {
      MC_ReadActualTorque_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Error = other.Error;
      Valid = other.Valid;
      Enable = other.Enable;
      Torque = other.Torque;
      ErrorID = other.ErrorID;
    }
  }

  MC_ReadActualTorque(void) {
    MC_ReadActualTorque_create(this, sizeof(*this));
  } 
  ~MC_ReadActualTorque(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Torque(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Torque(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_ReadActualTorque> property_list[8];
  static IEC_Property_Range property_range_list[4];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_ReadActualTorque* self = (MC_ReadActualTorque*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_ReadActualTorque* self = (MC_ReadActualTorque*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_ReadActualTorque_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_ReadActualVelocity {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Enable;
  IEC_BOOL Valid;
  IEC_BOOL Busy;
  IEC_BOOL Error;
  IEC_WORD ErrorID;
  IEC_LREAL Velocity;

  // this function block, sizeof : 32, dsize : 32, align : 8

  static bool __s_has_MC_ReadActualVelocity_on_copy;
  MC_ReadActualVelocity& operator=(MC_ReadActualVelocity&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Error = other.Error;
    Valid = other.Valid;
    Enable = other.Enable;
    native = other.native;
    ErrorID = other.ErrorID;
    Velocity = other.Velocity;
    return *this;
  }
  MC_ReadActualVelocity& operator=(const MC_ReadActualVelocity& other) {
    if (__s_has_MC_ReadActualVelocity_on_copy) {
      MC_ReadActualVelocity_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Error = other.Error;
      Valid = other.Valid;
      Enable = other.Enable;
      ErrorID = other.ErrorID;
      Velocity = other.Velocity;
    }
    return *this;
  }

  MC_ReadActualVelocity(MC_ReadActualVelocity&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Error = other.Error;
    Valid = other.Valid;
    Enable = other.Enable;
    native = other.native;
    ErrorID = other.ErrorID;
    Velocity = other.Velocity;
  }
  MC_ReadActualVelocity(const MC_ReadActualVelocity& other) : MC_ReadActualVelocity() {
    if (__s_has_MC_ReadActualVelocity_on_copy) {
      MC_ReadActualVelocity_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Error = other.Error;
      Valid = other.Valid;
      Enable = other.Enable;
      ErrorID = other.ErrorID;
      Velocity = other.Velocity;
    }
  }

  MC_ReadActualVelocity(void) {
    MC_ReadActualVelocity_create(this, sizeof(*this));
  } 
  ~MC_ReadActualVelocity(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_ReadActualVelocity> property_list[8];
  static IEC_Property_Range property_range_list[5];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_ReadActualVelocity* self = (MC_ReadActualVelocity*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_ReadActualVelocity* self = (MC_ReadActualVelocity*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_ReadActualVelocity_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_ReadAxisError {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Enable;
  IEC_BOOL Valid;
  IEC_BOOL Busy;
  IEC_BOOL Error;
  IEC_WORD ErrorID;
  IEC_BOOL AxisError;
  IEC_DWORD AxisErrorID;
  IEC_BOOL SWEndSwitchActive;

  // this param is padding for function block, sizeof : 32, dsize : 25, align : 8
  uint8_t __padding[7];

  static bool __s_has_MC_ReadAxisError_on_copy;
  MC_ReadAxisError& operator=(MC_ReadAxisError&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Error = other.Error;
    Valid = other.Valid;
    Enable = other.Enable;
    native = other.native;
    ErrorID = other.ErrorID;
    AxisError = other.AxisError;
    AxisErrorID = other.AxisErrorID;
    SWEndSwitchActive = other.SWEndSwitchActive;
    return *this;
  }
  MC_ReadAxisError& operator=(const MC_ReadAxisError& other) {
    if (__s_has_MC_ReadAxisError_on_copy) {
      MC_ReadAxisError_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Error = other.Error;
      Valid = other.Valid;
      Enable = other.Enable;
      ErrorID = other.ErrorID;
      AxisError = other.AxisError;
      AxisErrorID = other.AxisErrorID;
      SWEndSwitchActive = other.SWEndSwitchActive;
    }
    return *this;
  }

  MC_ReadAxisError(MC_ReadAxisError&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Error = other.Error;
    Valid = other.Valid;
    Enable = other.Enable;
    native = other.native;
    ErrorID = other.ErrorID;
    AxisError = other.AxisError;
    AxisErrorID = other.AxisErrorID;
    SWEndSwitchActive = other.SWEndSwitchActive;
  }
  MC_ReadAxisError(const MC_ReadAxisError& other) : MC_ReadAxisError() {
    if (__s_has_MC_ReadAxisError_on_copy) {
      MC_ReadAxisError_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Error = other.Error;
      Valid = other.Valid;
      Enable = other.Enable;
      ErrorID = other.ErrorID;
      AxisError = other.AxisError;
      AxisErrorID = other.AxisErrorID;
      SWEndSwitchActive = other.SWEndSwitchActive;
    }
  }

  MC_ReadAxisError(void) {
    MC_ReadAxisError_create(this, sizeof(*this));
  } 
  ~MC_ReadAxisError(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_AxisError(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_AxisErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_SWEndSwitchActive(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_AxisError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_AxisErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_SWEndSwitchActive(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_ReadAxisError> property_list[10];
  static IEC_Property_Range property_range_list[7];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_ReadAxisError* self = (MC_ReadAxisError*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_ReadAxisError* self = (MC_ReadAxisError*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_ReadAxisError_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_ReadBoolParameter {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Enable;
  IEC_DINT ParameterNumber;
  IEC_BOOL Valid;
  IEC_BOOL Busy;
  IEC_BOOL Error;
  IEC_WORD ErrorID;
  IEC_BOOL Value;

  // this param is padding for function block, sizeof : 32, dsize : 27, align : 8
  uint8_t __padding[5];

  static bool __s_has_MC_ReadBoolParameter_on_copy;
  MC_ReadBoolParameter& operator=(MC_ReadBoolParameter&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Error = other.Error;
    Valid = other.Valid;
    Value = other.Value;
    Enable = other.Enable;
    native = other.native;
    ErrorID = other.ErrorID;
    ParameterNumber = other.ParameterNumber;
    return *this;
  }
  MC_ReadBoolParameter& operator=(const MC_ReadBoolParameter& other) {
    if (__s_has_MC_ReadBoolParameter_on_copy) {
      MC_ReadBoolParameter_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Error = other.Error;
      Valid = other.Valid;
      Value = other.Value;
      Enable = other.Enable;
      ErrorID = other.ErrorID;
      ParameterNumber = other.ParameterNumber;
    }
    return *this;
  }

  MC_ReadBoolParameter(MC_ReadBoolParameter&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Error = other.Error;
    Valid = other.Valid;
    Value = other.Value;
    Enable = other.Enable;
    native = other.native;
    ErrorID = other.ErrorID;
    ParameterNumber = other.ParameterNumber;
  }
  MC_ReadBoolParameter(const MC_ReadBoolParameter& other) : MC_ReadBoolParameter() {
    if (__s_has_MC_ReadBoolParameter_on_copy) {
      MC_ReadBoolParameter_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Error = other.Error;
      Valid = other.Valid;
      Value = other.Value;
      Enable = other.Enable;
      ErrorID = other.ErrorID;
      ParameterNumber = other.ParameterNumber;
    }
  }

  MC_ReadBoolParameter(void) {
    MC_ReadBoolParameter_create(this, sizeof(*this));
  } 
  ~MC_ReadBoolParameter(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ParameterNumber(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Value(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ParameterNumber(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Value(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_ReadBoolParameter> property_list[9];
  static IEC_Property_Range property_range_list[5];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_ReadBoolParameter* self = (MC_ReadBoolParameter*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_ReadBoolParameter* self = (MC_ReadBoolParameter*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_ReadBoolParameter_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_ReadCommandPosition {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Enable;
  IEC_BOOL Valid;
  IEC_BOOL Busy;
  IEC_LREAL Position;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 32, dsize : 28, align : 8
  uint8_t __padding[4];

  static bool __s_has_MC_ReadCommandPosition_on_copy;
  MC_ReadCommandPosition& operator=(MC_ReadCommandPosition&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Error = other.Error;
    Valid = other.Valid;
    Enable = other.Enable;
    native = other.native;
    ErrorID = other.ErrorID;
    Position = other.Position;
    return *this;
  }
  MC_ReadCommandPosition& operator=(const MC_ReadCommandPosition& other) {
    if (__s_has_MC_ReadCommandPosition_on_copy) {
      MC_ReadCommandPosition_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Error = other.Error;
      Valid = other.Valid;
      Enable = other.Enable;
      ErrorID = other.ErrorID;
      Position = other.Position;
    }
    return *this;
  }

  MC_ReadCommandPosition(MC_ReadCommandPosition&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Error = other.Error;
    Valid = other.Valid;
    Enable = other.Enable;
    native = other.native;
    ErrorID = other.ErrorID;
    Position = other.Position;
  }
  MC_ReadCommandPosition(const MC_ReadCommandPosition& other) : MC_ReadCommandPosition() {
    if (__s_has_MC_ReadCommandPosition_on_copy) {
      MC_ReadCommandPosition_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Error = other.Error;
      Valid = other.Valid;
      Enable = other.Enable;
      ErrorID = other.ErrorID;
      Position = other.Position;
    }
  }

  MC_ReadCommandPosition(void) {
    MC_ReadCommandPosition_create(this, sizeof(*this));
  } 
  ~MC_ReadCommandPosition(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Position(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Position(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_ReadCommandPosition> property_list[8];
  static IEC_Property_Range property_range_list[5];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_ReadCommandPosition* self = (MC_ReadCommandPosition*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_ReadCommandPosition* self = (MC_ReadCommandPosition*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_ReadCommandPosition_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_ReadParameter {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Enable;
  IEC_DINT ParameterNumber;
  IEC_BOOL Valid;
  IEC_BOOL Busy;
  IEC_BOOL Error;
  IEC_WORD ErrorID;
  IEC_LREAL Value;

  // this function block, sizeof : 40, dsize : 40, align : 8

  static bool __s_has_MC_ReadParameter_on_copy;
  MC_ReadParameter& operator=(MC_ReadParameter&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Error = other.Error;
    Valid = other.Valid;
    Value = other.Value;
    Enable = other.Enable;
    native = other.native;
    ErrorID = other.ErrorID;
    ParameterNumber = other.ParameterNumber;
    return *this;
  }
  MC_ReadParameter& operator=(const MC_ReadParameter& other) {
    if (__s_has_MC_ReadParameter_on_copy) {
      MC_ReadParameter_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Error = other.Error;
      Valid = other.Valid;
      Value = other.Value;
      Enable = other.Enable;
      ErrorID = other.ErrorID;
      ParameterNumber = other.ParameterNumber;
    }
    return *this;
  }

  MC_ReadParameter(MC_ReadParameter&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Error = other.Error;
    Valid = other.Valid;
    Value = other.Value;
    Enable = other.Enable;
    native = other.native;
    ErrorID = other.ErrorID;
    ParameterNumber = other.ParameterNumber;
  }
  MC_ReadParameter(const MC_ReadParameter& other) : MC_ReadParameter() {
    if (__s_has_MC_ReadParameter_on_copy) {
      MC_ReadParameter_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Error = other.Error;
      Valid = other.Valid;
      Value = other.Value;
      Enable = other.Enable;
      ErrorID = other.ErrorID;
      ParameterNumber = other.ParameterNumber;
    }
  }

  MC_ReadParameter(void) {
    MC_ReadParameter_create(this, sizeof(*this));
  } 
  ~MC_ReadParameter(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ParameterNumber(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Value(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ParameterNumber(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Value(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_ReadParameter> property_list[9];
  static IEC_Property_Range property_range_list[5];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_ReadParameter* self = (MC_ReadParameter*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_ReadParameter* self = (MC_ReadParameter*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_ReadParameter_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_ReadStatus {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Enable;
  IEC_BOOL Valid;
  IEC_BOOL Busy;
  IEC_BOOL Error;
  IEC_WORD ErrorID;
  IEC_BOOL Disabled;
  IEC_BOOL ErrorStop;
  IEC_BOOL Stopping;
  IEC_BOOL Standstill;
  IEC_BOOL DiscreteMotion;
  IEC_BOOL ContinuousMotion;
  IEC_BOOL SynchronizedMotion;
  IEC_BOOL Homing;
  IEC_BOOL ConstantVelocity;
  IEC_BOOL Accelerating;
  IEC_BOOL Decelerating;
  IEC_BOOL FBErrorOccurred;

  // this param is padding for function block, sizeof : 32, dsize : 30, align : 8
  uint8_t __padding[2];

  static bool __s_has_MC_ReadStatus_on_copy;
  MC_ReadStatus& operator=(MC_ReadStatus&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Error = other.Error;
    Valid = other.Valid;
    Enable = other.Enable;
    Homing = other.Homing;
    native = other.native;
    ErrorID = other.ErrorID;
    Disabled = other.Disabled;
    Stopping = other.Stopping;
    ErrorStop = other.ErrorStop;
    Standstill = other.Standstill;
    Accelerating = other.Accelerating;
    Decelerating = other.Decelerating;
    DiscreteMotion = other.DiscreteMotion;
    FBErrorOccurred = other.FBErrorOccurred;
    ConstantVelocity = other.ConstantVelocity;
    ContinuousMotion = other.ContinuousMotion;
    SynchronizedMotion = other.SynchronizedMotion;
    return *this;
  }
  MC_ReadStatus& operator=(const MC_ReadStatus& other) {
    if (__s_has_MC_ReadStatus_on_copy) {
      MC_ReadStatus_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Error = other.Error;
      Valid = other.Valid;
      Enable = other.Enable;
      Homing = other.Homing;
      ErrorID = other.ErrorID;
      Disabled = other.Disabled;
      Stopping = other.Stopping;
      ErrorStop = other.ErrorStop;
      Standstill = other.Standstill;
      Accelerating = other.Accelerating;
      Decelerating = other.Decelerating;
      DiscreteMotion = other.DiscreteMotion;
      FBErrorOccurred = other.FBErrorOccurred;
      ConstantVelocity = other.ConstantVelocity;
      ContinuousMotion = other.ContinuousMotion;
      SynchronizedMotion = other.SynchronizedMotion;
    }
    return *this;
  }

  MC_ReadStatus(MC_ReadStatus&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Error = other.Error;
    Valid = other.Valid;
    Enable = other.Enable;
    Homing = other.Homing;
    native = other.native;
    ErrorID = other.ErrorID;
    Disabled = other.Disabled;
    Stopping = other.Stopping;
    ErrorStop = other.ErrorStop;
    Standstill = other.Standstill;
    Accelerating = other.Accelerating;
    Decelerating = other.Decelerating;
    DiscreteMotion = other.DiscreteMotion;
    FBErrorOccurred = other.FBErrorOccurred;
    ConstantVelocity = other.ConstantVelocity;
    ContinuousMotion = other.ContinuousMotion;
    SynchronizedMotion = other.SynchronizedMotion;
  }
  MC_ReadStatus(const MC_ReadStatus& other) : MC_ReadStatus() {
    if (__s_has_MC_ReadStatus_on_copy) {
      MC_ReadStatus_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Error = other.Error;
      Valid = other.Valid;
      Enable = other.Enable;
      Homing = other.Homing;
      ErrorID = other.ErrorID;
      Disabled = other.Disabled;
      Stopping = other.Stopping;
      ErrorStop = other.ErrorStop;
      Standstill = other.Standstill;
      Accelerating = other.Accelerating;
      Decelerating = other.Decelerating;
      DiscreteMotion = other.DiscreteMotion;
      FBErrorOccurred = other.FBErrorOccurred;
      ConstantVelocity = other.ConstantVelocity;
      ContinuousMotion = other.ContinuousMotion;
      SynchronizedMotion = other.SynchronizedMotion;
    }
  }

  MC_ReadStatus(void) {
    MC_ReadStatus_create(this, sizeof(*this));
  } 
  ~MC_ReadStatus(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Disabled(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorStop(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Stopping(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Standstill(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_DiscreteMotion(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ContinuousMotion(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_SynchronizedMotion(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Homing(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ConstantVelocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Accelerating(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Decelerating(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_FBErrorOccurred(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Disabled(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorStop(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Stopping(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Standstill(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_DiscreteMotion(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ContinuousMotion(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_SynchronizedMotion(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Homing(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ConstantVelocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Accelerating(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Decelerating(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_FBErrorOccurred(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_ReadStatus> property_list[19];
  static IEC_Property_Range property_range_list[12];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_ReadStatus* self = (MC_ReadStatus*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_ReadStatus* self = (MC_ReadStatus*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_ReadStatus_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_Reset {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Execute;
  IEC_BOOL Done;
  IEC_BOOL Busy;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 24, dsize : 18, align : 8
  uint8_t __padding[6];

  static bool __s_has_MC_Reset_on_copy;
  MC_Reset& operator=(MC_Reset&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    return *this;
  }
  MC_Reset& operator=(const MC_Reset& other) {
    if (__s_has_MC_Reset_on_copy) {
      MC_Reset_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
    }
    return *this;
  }

  MC_Reset(MC_Reset&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
  }
  MC_Reset(const MC_Reset& other) : MC_Reset() {
    if (__s_has_MC_Reset_on_copy) {
      MC_Reset_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
    }
  }

  MC_Reset(void) {
    MC_Reset_create(this, sizeof(*this));
  } 
  ~MC_Reset(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_Reset> property_list[7];
  static IEC_Property_Range property_range_list[4];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_Reset* self = (MC_Reset*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_Reset* self = (MC_Reset*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_Reset_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_SetPosition {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Execute;
  IEC_LREAL Position;
  IEC_BOOL Mode;
  IEC_BOOL Done;
  IEC_BOOL Busy;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 32, dsize : 30, align : 8
  uint8_t __padding[2];

  static bool __s_has_MC_SetPosition_on_copy;
  MC_SetPosition& operator=(MC_SetPosition&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Mode = other.Mode;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Position = other.Position;
    return *this;
  }
  MC_SetPosition& operator=(const MC_SetPosition& other) {
    if (__s_has_MC_SetPosition_on_copy) {
      MC_SetPosition_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Mode = other.Mode;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Position = other.Position;
    }
    return *this;
  }

  MC_SetPosition(MC_SetPosition&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Mode = other.Mode;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Position = other.Position;
  }
  MC_SetPosition(const MC_SetPosition& other) : MC_SetPosition() {
    if (__s_has_MC_SetPosition_on_copy) {
      MC_SetPosition_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Mode = other.Mode;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Position = other.Position;
    }
  }

  MC_SetPosition(void) {
    MC_SetPosition_create(this, sizeof(*this));
  } 
  ~MC_SetPosition(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Position(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Mode(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Position(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Mode(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_SetPosition> property_list[9];
  static IEC_Property_Range property_range_list[5];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_SetPosition* self = (MC_SetPosition*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_SetPosition* self = (MC_SetPosition*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_SetPosition_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_Stop {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Execute;
  IEC_LREAL Deceleration;
  IEC_LREAL Jerk;
  IEC_BOOL Done;
  IEC_BOOL Busy;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 40, dsize : 38, align : 8
  uint8_t __padding[2];

  static bool __s_has_MC_Stop_on_copy;
  MC_Stop& operator=(MC_Stop&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Jerk = other.Jerk;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Deceleration = other.Deceleration;
    return *this;
  }
  MC_Stop& operator=(const MC_Stop& other) {
    if (__s_has_MC_Stop_on_copy) {
      MC_Stop_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Jerk = other.Jerk;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Deceleration = other.Deceleration;
    }
    return *this;
  }

  MC_Stop(MC_Stop&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Jerk = other.Jerk;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    Deceleration = other.Deceleration;
  }
  MC_Stop(const MC_Stop& other) : MC_Stop() {
    if (__s_has_MC_Stop_on_copy) {
      MC_Stop_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Jerk = other.Jerk;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      Deceleration = other.Deceleration;
    }
  }

  MC_Stop(void) {
    MC_Stop_create(this, sizeof(*this));
  } 
  ~MC_Stop(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_Stop> property_list[9];
  static IEC_Property_Range property_range_list[5];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_Stop* self = (MC_Stop*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_Stop* self = (MC_Stop*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_Stop_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_TouchProbe {
  IEC_ULINT native;
  AXIS_REF Axis;
  TRIGGER_REF TriggerInput;
  IEC_BOOL Execute;
  IEC_BOOL WindowOnly;
  IEC_LREAL FirstPosition;
  IEC_LREAL LastPosition;
  IEC_BOOL Done;
  IEC_BOOL Busy;
  IEC_BOOL Error;
  IEC_WORD ErrorID;
  IEC_LREAL RecordedPosition;
  IEC_BOOL CommandAborted;

  // this param is padding for function block, sizeof : 64, dsize : 57, align : 8
  uint8_t __padding[7];

  static bool __s_has_MC_TouchProbe_on_copy;
  MC_TouchProbe& operator=(MC_TouchProbe&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    WindowOnly = other.WindowOnly;
    LastPosition = other.LastPosition;
    TriggerInput = other.TriggerInput;
    FirstPosition = other.FirstPosition;
    CommandAborted = other.CommandAborted;
    RecordedPosition = other.RecordedPosition;
    return *this;
  }
  MC_TouchProbe& operator=(const MC_TouchProbe& other) {
    if (__s_has_MC_TouchProbe_on_copy) {
      MC_TouchProbe_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      WindowOnly = other.WindowOnly;
      LastPosition = other.LastPosition;
      TriggerInput = other.TriggerInput;
      FirstPosition = other.FirstPosition;
      CommandAborted = other.CommandAborted;
      RecordedPosition = other.RecordedPosition;
    }
    return *this;
  }

  MC_TouchProbe(MC_TouchProbe&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    WindowOnly = other.WindowOnly;
    LastPosition = other.LastPosition;
    TriggerInput = other.TriggerInput;
    FirstPosition = other.FirstPosition;
    CommandAborted = other.CommandAborted;
    RecordedPosition = other.RecordedPosition;
  }
  MC_TouchProbe(const MC_TouchProbe& other) : MC_TouchProbe() {
    if (__s_has_MC_TouchProbe_on_copy) {
      MC_TouchProbe_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      WindowOnly = other.WindowOnly;
      LastPosition = other.LastPosition;
      TriggerInput = other.TriggerInput;
      FirstPosition = other.FirstPosition;
      CommandAborted = other.CommandAborted;
      RecordedPosition = other.RecordedPosition;
    }
  }

  MC_TouchProbe(void) {
    MC_TouchProbe_create(this, sizeof(*this));
  } 
  ~MC_TouchProbe(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_TriggerInput(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_WindowOnly(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_FirstPosition(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_LastPosition(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_RecordedPosition(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_TriggerInput(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_WindowOnly(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_FirstPosition(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_LastPosition(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_RecordedPosition(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_TouchProbe> property_list[13];
  static IEC_Property_Range property_range_list[9];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_TouchProbe* self = (MC_TouchProbe*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_TouchProbe* self = (MC_TouchProbe*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_TouchProbe_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_VelocityProfile {
  IEC_ULINT native;
  AXIS_REF Axis;
  MC_TV_REF TimeVelocity;
  IEC_BOOL Execute;
  IEC_INT ArraySize;
  IEC_LREAL VelocityScale;
  IEC_LREAL Offset;
  IEC_BOOL Done;
  IEC_BOOL Busy;
  IEC_BOOL CommandAborted;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 1656, dsize : 1654, align : 8
  uint8_t __padding[2];

  static bool __s_has_MC_VelocityProfile_on_copy;
  MC_VelocityProfile& operator=(MC_VelocityProfile&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    Offset = other.Offset;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    ArraySize = other.ArraySize;
    TimeVelocity = other.TimeVelocity;
    VelocityScale = other.VelocityScale;
    CommandAborted = other.CommandAborted;
    return *this;
  }
  MC_VelocityProfile& operator=(const MC_VelocityProfile& other) {
    if (__s_has_MC_VelocityProfile_on_copy) {
      MC_VelocityProfile_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      Offset = other.Offset;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      ArraySize = other.ArraySize;
      TimeVelocity = other.TimeVelocity;
      VelocityScale = other.VelocityScale;
      CommandAborted = other.CommandAborted;
    }
    return *this;
  }

  MC_VelocityProfile(MC_VelocityProfile&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    Offset = other.Offset;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    ArraySize = other.ArraySize;
    TimeVelocity = other.TimeVelocity;
    VelocityScale = other.VelocityScale;
    CommandAborted = other.CommandAborted;
  }
  MC_VelocityProfile(const MC_VelocityProfile& other) : MC_VelocityProfile() {
    if (__s_has_MC_VelocityProfile_on_copy) {
      MC_VelocityProfile_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      Offset = other.Offset;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      ArraySize = other.ArraySize;
      TimeVelocity = other.TimeVelocity;
      VelocityScale = other.VelocityScale;
      CommandAborted = other.CommandAborted;
    }
  }

  MC_VelocityProfile(void) {
    MC_VelocityProfile_create(this, sizeof(*this));
  } 
  ~MC_VelocityProfile(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_TimeVelocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ArraySize(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_VelocityScale(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Offset(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_TimeVelocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ArraySize(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_VelocityScale(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Offset(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_VelocityProfile> property_list[12];
  static IEC_Property_Range property_range_list[8];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_VelocityProfile* self = (MC_VelocityProfile*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_VelocityProfile* self = (MC_VelocityProfile*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_VelocityProfile_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_WriteBoolParameter {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Execute;
  IEC_DINT ParameterNumber;
  IEC_BOOL Value;
  IEC_BOOL Done;
  IEC_BOOL Busy;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 32, dsize : 26, align : 8
  uint8_t __padding[6];

  static bool __s_has_MC_WriteBoolParameter_on_copy;
  MC_WriteBoolParameter& operator=(MC_WriteBoolParameter&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    Value = other.Value;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    ParameterNumber = other.ParameterNumber;
    return *this;
  }
  MC_WriteBoolParameter& operator=(const MC_WriteBoolParameter& other) {
    if (__s_has_MC_WriteBoolParameter_on_copy) {
      MC_WriteBoolParameter_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      Value = other.Value;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      ParameterNumber = other.ParameterNumber;
    }
    return *this;
  }

  MC_WriteBoolParameter(MC_WriteBoolParameter&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    Value = other.Value;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    ParameterNumber = other.ParameterNumber;
  }
  MC_WriteBoolParameter(const MC_WriteBoolParameter& other) : MC_WriteBoolParameter() {
    if (__s_has_MC_WriteBoolParameter_on_copy) {
      MC_WriteBoolParameter_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      Value = other.Value;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      ParameterNumber = other.ParameterNumber;
    }
  }

  MC_WriteBoolParameter(void) {
    MC_WriteBoolParameter_create(this, sizeof(*this));
  } 
  ~MC_WriteBoolParameter(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ParameterNumber(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Value(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ParameterNumber(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Value(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_WriteBoolParameter> property_list[9];
  static IEC_Property_Range property_range_list[5];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_WriteBoolParameter* self = (MC_WriteBoolParameter*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_WriteBoolParameter* self = (MC_WriteBoolParameter*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_WriteBoolParameter_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_WriteParameter {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Execute;
  IEC_DINT ParameterNumber;
  IEC_LREAL Value;
  IEC_BOOL Done;
  IEC_BOOL Busy;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 40, dsize : 38, align : 8
  uint8_t __padding[2];

  static bool __s_has_MC_WriteParameter_on_copy;
  MC_WriteParameter& operator=(MC_WriteParameter&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    Value = other.Value;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    ParameterNumber = other.ParameterNumber;
    return *this;
  }
  MC_WriteParameter& operator=(const MC_WriteParameter& other) {
    if (__s_has_MC_WriteParameter_on_copy) {
      MC_WriteParameter_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      Value = other.Value;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      ParameterNumber = other.ParameterNumber;
    }
    return *this;
  }

  MC_WriteParameter(MC_WriteParameter&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    Value = other.Value;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    ParameterNumber = other.ParameterNumber;
  }
  MC_WriteParameter(const MC_WriteParameter& other) : MC_WriteParameter() {
    if (__s_has_MC_WriteParameter_on_copy) {
      MC_WriteParameter_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      Value = other.Value;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      ParameterNumber = other.ParameterNumber;
    }
  }

  MC_WriteParameter(void) {
    MC_WriteParameter_create(this, sizeof(*this));
  } 
  ~MC_WriteParameter(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ParameterNumber(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Value(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ParameterNumber(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Value(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_WriteParameter> property_list[9];
  static IEC_Property_Range property_range_list[5];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_WriteParameter* self = (MC_WriteParameter*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_WriteParameter* self = (MC_WriteParameter*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_WriteParameter_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct ZMC_FollowPosition {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL bExecute;
  IEC_LREAL fSetPosition;
  IEC_BOOL bBusy;
  IEC_BOOL bCommandAborted;
  IEC_BOOL bError;
  IEC_WORD iErrorID;

  // this param is padding for function block, sizeof : 32, dsize : 30, align : 8
  uint8_t __padding[2];

  static bool __s_has_ZMC_FollowPosition_on_copy;
  ZMC_FollowPosition& operator=(ZMC_FollowPosition&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    bBusy = other.bBusy;
    bError = other.bError;
    native = other.native;
    bExecute = other.bExecute;
    iErrorID = other.iErrorID;
    fSetPosition = other.fSetPosition;
    bCommandAborted = other.bCommandAborted;
    return *this;
  }
  ZMC_FollowPosition& operator=(const ZMC_FollowPosition& other) {
    if (__s_has_ZMC_FollowPosition_on_copy) {
      ZMC_FollowPosition_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      bBusy = other.bBusy;
      bError = other.bError;
      bExecute = other.bExecute;
      iErrorID = other.iErrorID;
      fSetPosition = other.fSetPosition;
      bCommandAborted = other.bCommandAborted;
    }
    return *this;
  }

  ZMC_FollowPosition(ZMC_FollowPosition&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    bBusy = other.bBusy;
    bError = other.bError;
    native = other.native;
    bExecute = other.bExecute;
    iErrorID = other.iErrorID;
    fSetPosition = other.fSetPosition;
    bCommandAborted = other.bCommandAborted;
  }
  ZMC_FollowPosition(const ZMC_FollowPosition& other) : ZMC_FollowPosition() {
    if (__s_has_ZMC_FollowPosition_on_copy) {
      ZMC_FollowPosition_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      bBusy = other.bBusy;
      bError = other.bError;
      bExecute = other.bExecute;
      iErrorID = other.iErrorID;
      fSetPosition = other.fSetPosition;
      bCommandAborted = other.bCommandAborted;
    }
  }

  ZMC_FollowPosition(void) {
    ZMC_FollowPosition_create(this, sizeof(*this));
  } 
  ~ZMC_FollowPosition(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bExecute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_fSetPosition(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bBusy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bCommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bError(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_iErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bExecute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_fSetPosition(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bBusy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bCommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_iErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<ZMC_FollowPosition> property_list[8];
  static IEC_Property_Range property_range_list[6];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    ZMC_FollowPosition* self = (ZMC_FollowPosition*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      ZMC_FollowPosition* self = (ZMC_FollowPosition*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define ZMC_FollowPosition_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct ZMC_GetTappetValue {
  IEC_ULINT native;
  ZMC_TappetData* Tappets;
  IEC_INT iID;
  IEC_BOOL bInitValue;
  IEC_BOOL bSetInitValueAtReset;
  IEC_BOOL bTappet;

  // this param is padding for function block, sizeof : 24, dsize : 17, align : 8
  uint8_t __padding[7];

  static bool __s_has_ZMC_GetTappetValue_on_copy;
  ZMC_GetTappetValue& operator=(ZMC_GetTappetValue&& other) noexcept {
    this->deinit_();
    iID = other.iID;
    native = other.native;
    Tappets = other.Tappets;
    other.Tappets = nullptr;
    bTappet = other.bTappet;
    bInitValue = other.bInitValue;
    bSetInitValueAtReset = other.bSetInitValueAtReset;
    return *this;
  }
  ZMC_GetTappetValue& operator=(const ZMC_GetTappetValue& other) {
    if (__s_has_ZMC_GetTappetValue_on_copy) {
      ZMC_GetTappetValue_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      iID = other.iID;
      Tappets = other.Tappets;
      bTappet = other.bTappet;
      bInitValue = other.bInitValue;
      bSetInitValueAtReset = other.bSetInitValueAtReset;
    }
    return *this;
  }

  ZMC_GetTappetValue(ZMC_GetTappetValue&& other) noexcept {
    iID = other.iID;
    native = other.native;
    Tappets = other.Tappets;
    other.Tappets = nullptr;
    bTappet = other.bTappet;
    bInitValue = other.bInitValue;
    bSetInitValueAtReset = other.bSetInitValueAtReset;
  }
  ZMC_GetTappetValue(const ZMC_GetTappetValue& other) : ZMC_GetTappetValue() {
    if (__s_has_ZMC_GetTappetValue_on_copy) {
      ZMC_GetTappetValue_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      iID = other.iID;
      Tappets = other.Tappets;
      bTappet = other.bTappet;
      bInitValue = other.bInitValue;
      bSetInitValueAtReset = other.bSetInitValueAtReset;
    }
  }

  ZMC_GetTappetValue(void) {
    ZMC_GetTappetValue_create(this, sizeof(*this));
  } 
  ~ZMC_GetTappetValue(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Tappets(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_iID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bInitValue(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bSetInitValueAtReset(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bTappet(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Tappets(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_iID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bInitValue(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bSetInitValueAtReset(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bTappet(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<ZMC_GetTappetValue> property_list[6];
  static IEC_Property_Range property_range_list[5];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    ZMC_GetTappetValue* self = (ZMC_GetTappetValue*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      ZMC_GetTappetValue* self = (ZMC_GetTappetValue*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define ZMC_GetTappetValue_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct ZMC_ReadCAM {
  IEC_ULINT native;
  IEC_BOOL bExecute;
  IEC_String<IEC_CHAR, 80> sFileName;
  IEC_BOOL bDone;
  IEC_BOOL bBusy;
  IEC_BOOL bError;
  IEC_WORD ErrorID;
  MC_CAM_REF CAM;

  // this param is padding for function block, sizeof : 104, dsize : 100, align : 8
  uint8_t __padding[4];

  static bool __s_has_ZMC_ReadCAM_on_copy;
  ZMC_ReadCAM& operator=(ZMC_ReadCAM&& other) noexcept {
    this->deinit_();
    CAM = other.CAM;
    other.CAM = nullptr;
    bBusy = other.bBusy;
    bDone = other.bDone;
    bError = other.bError;
    native = other.native;
    ErrorID = other.ErrorID;
    bExecute = other.bExecute;
    sFileName = other.sFileName;
    return *this;
  }
  ZMC_ReadCAM& operator=(const ZMC_ReadCAM& other) {
    if (__s_has_ZMC_ReadCAM_on_copy) {
      ZMC_ReadCAM_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      CAM = other.CAM;
      bBusy = other.bBusy;
      bDone = other.bDone;
      bError = other.bError;
      ErrorID = other.ErrorID;
      bExecute = other.bExecute;
      sFileName = other.sFileName;
    }
    return *this;
  }

  ZMC_ReadCAM(ZMC_ReadCAM&& other) noexcept {
    CAM = other.CAM;
    other.CAM = nullptr;
    bBusy = other.bBusy;
    bDone = other.bDone;
    bError = other.bError;
    native = other.native;
    ErrorID = other.ErrorID;
    bExecute = other.bExecute;
    sFileName = other.sFileName;
  }
  ZMC_ReadCAM(const ZMC_ReadCAM& other) : ZMC_ReadCAM() {
    if (__s_has_ZMC_ReadCAM_on_copy) {
      ZMC_ReadCAM_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      CAM = other.CAM;
      bBusy = other.bBusy;
      bDone = other.bDone;
      bError = other.bError;
      ErrorID = other.ErrorID;
      bExecute = other.bExecute;
      sFileName = other.sFileName;
    }
  }

  ZMC_ReadCAM(void) {
    ZMC_ReadCAM_create(this, sizeof(*this));
  } 
  ~ZMC_ReadCAM(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bExecute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_sFileName(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bDone(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bBusy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bError(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CAM(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bExecute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_sFileName(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bDone(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bBusy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CAM(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<ZMC_ReadCAM> property_list[8];
  static IEC_Property_Range property_range_list[6];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    ZMC_ReadCAM* self = (ZMC_ReadCAM*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      ZMC_ReadCAM* self = (ZMC_ReadCAM*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define ZMC_ReadCAM_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct ZMC_WriteCAM {
  IEC_ULINT native;
  MC_CAM_REF CAM;
  IEC_BOOL bExecute;
  IEC_String<IEC_CHAR, 80> sFileName;
  IEC_BOOL bDone;
  IEC_BOOL bBusy;
  IEC_BOOL bError;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 104, dsize : 100, align : 8
  uint8_t __padding[4];

  static bool __s_has_ZMC_WriteCAM_on_copy;
  ZMC_WriteCAM& operator=(ZMC_WriteCAM&& other) noexcept {
    this->deinit_();
    CAM = other.CAM;
    other.CAM = nullptr;
    bBusy = other.bBusy;
    bDone = other.bDone;
    bError = other.bError;
    native = other.native;
    ErrorID = other.ErrorID;
    bExecute = other.bExecute;
    sFileName = other.sFileName;
    return *this;
  }
  ZMC_WriteCAM& operator=(const ZMC_WriteCAM& other) {
    if (__s_has_ZMC_WriteCAM_on_copy) {
      ZMC_WriteCAM_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      CAM = other.CAM;
      bBusy = other.bBusy;
      bDone = other.bDone;
      bError = other.bError;
      ErrorID = other.ErrorID;
      bExecute = other.bExecute;
      sFileName = other.sFileName;
    }
    return *this;
  }

  ZMC_WriteCAM(ZMC_WriteCAM&& other) noexcept {
    CAM = other.CAM;
    other.CAM = nullptr;
    bBusy = other.bBusy;
    bDone = other.bDone;
    bError = other.bError;
    native = other.native;
    ErrorID = other.ErrorID;
    bExecute = other.bExecute;
    sFileName = other.sFileName;
  }
  ZMC_WriteCAM(const ZMC_WriteCAM& other) : ZMC_WriteCAM() {
    if (__s_has_ZMC_WriteCAM_on_copy) {
      ZMC_WriteCAM_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      CAM = other.CAM;
      bBusy = other.bBusy;
      bDone = other.bDone;
      bError = other.bError;
      ErrorID = other.ErrorID;
      bExecute = other.bExecute;
      sFileName = other.sFileName;
    }
  }

  ZMC_WriteCAM(void) {
    ZMC_WriteCAM_create(this, sizeof(*this));
  } 
  ~ZMC_WriteCAM(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_CAM(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bExecute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_sFileName(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bDone(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bBusy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bError(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_CAM(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bExecute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_sFileName(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bDone(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bBusy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<ZMC_WriteCAM> property_list[8];
  static IEC_Property_Range property_range_list[6];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    ZMC_WriteCAM* self = (ZMC_WriteCAM*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      ZMC_WriteCAM* self = (ZMC_WriteCAM*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define ZMC_WriteCAM_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_ReadActualDriveValues {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Enable;
  IEC_BOOL Valid;
  IEC_BOOL Busy;
  IEC_BOOL Error;
  IEC_WORD ErrorID;
  IEC_DINT Position;
  IEC_DINT Velocity;
  IEC_DINT Acceleration;
  IEC_DINT Jerk;

  // this param is padding for function block, sizeof : 40, dsize : 36, align : 8
  uint8_t __padding[4];

  static bool __s_has_MC_ReadActualDriveValues_on_copy;
  MC_ReadActualDriveValues& operator=(MC_ReadActualDriveValues&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Jerk = other.Jerk;
    Error = other.Error;
    Valid = other.Valid;
    Enable = other.Enable;
    native = other.native;
    ErrorID = other.ErrorID;
    Position = other.Position;
    Velocity = other.Velocity;
    Acceleration = other.Acceleration;
    return *this;
  }
  MC_ReadActualDriveValues& operator=(const MC_ReadActualDriveValues& other) {
    if (__s_has_MC_ReadActualDriveValues_on_copy) {
      MC_ReadActualDriveValues_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Jerk = other.Jerk;
      Error = other.Error;
      Valid = other.Valid;
      Enable = other.Enable;
      ErrorID = other.ErrorID;
      Position = other.Position;
      Velocity = other.Velocity;
      Acceleration = other.Acceleration;
    }
    return *this;
  }

  MC_ReadActualDriveValues(MC_ReadActualDriveValues&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Jerk = other.Jerk;
    Error = other.Error;
    Valid = other.Valid;
    Enable = other.Enable;
    native = other.native;
    ErrorID = other.ErrorID;
    Position = other.Position;
    Velocity = other.Velocity;
    Acceleration = other.Acceleration;
  }
  MC_ReadActualDriveValues(const MC_ReadActualDriveValues& other) : MC_ReadActualDriveValues() {
    if (__s_has_MC_ReadActualDriveValues_on_copy) {
      MC_ReadActualDriveValues_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Jerk = other.Jerk;
      Error = other.Error;
      Valid = other.Valid;
      Enable = other.Enable;
      ErrorID = other.ErrorID;
      Position = other.Position;
      Velocity = other.Velocity;
      Acceleration = other.Acceleration;
    }
  }

  MC_ReadActualDriveValues(void) {
    MC_ReadActualDriveValues_create(this, sizeof(*this));
  } 
  ~MC_ReadActualDriveValues(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Position(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Position(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_ReadActualDriveValues> property_list[11];
  static IEC_Property_Range property_range_list[6];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_ReadActualDriveValues* self = (MC_ReadActualDriveValues*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_ReadActualDriveValues* self = (MC_ReadActualDriveValues*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_ReadActualDriveValues_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_ReadActualValues {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Enable;
  IEC_BOOL Valid;
  IEC_BOOL Busy;
  IEC_BOOL Error;
  IEC_WORD ErrorID;
  IEC_LREAL Position;
  IEC_LREAL Velocity;
  IEC_LREAL Acceleration;
  IEC_LREAL Jerk;

  // this function block, sizeof : 56, dsize : 56, align : 8

  static bool __s_has_MC_ReadActualValues_on_copy;
  MC_ReadActualValues& operator=(MC_ReadActualValues&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Jerk = other.Jerk;
    Error = other.Error;
    Valid = other.Valid;
    Enable = other.Enable;
    native = other.native;
    ErrorID = other.ErrorID;
    Position = other.Position;
    Velocity = other.Velocity;
    Acceleration = other.Acceleration;
    return *this;
  }
  MC_ReadActualValues& operator=(const MC_ReadActualValues& other) {
    if (__s_has_MC_ReadActualValues_on_copy) {
      MC_ReadActualValues_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Jerk = other.Jerk;
      Error = other.Error;
      Valid = other.Valid;
      Enable = other.Enable;
      ErrorID = other.ErrorID;
      Position = other.Position;
      Velocity = other.Velocity;
      Acceleration = other.Acceleration;
    }
    return *this;
  }

  MC_ReadActualValues(MC_ReadActualValues&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Jerk = other.Jerk;
    Error = other.Error;
    Valid = other.Valid;
    Enable = other.Enable;
    native = other.native;
    ErrorID = other.ErrorID;
    Position = other.Position;
    Velocity = other.Velocity;
    Acceleration = other.Acceleration;
  }
  MC_ReadActualValues(const MC_ReadActualValues& other) : MC_ReadActualValues() {
    if (__s_has_MC_ReadActualValues_on_copy) {
      MC_ReadActualValues_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Jerk = other.Jerk;
      Error = other.Error;
      Valid = other.Valid;
      Enable = other.Enable;
      ErrorID = other.ErrorID;
      Position = other.Position;
      Velocity = other.Velocity;
      Acceleration = other.Acceleration;
    }
  }

  MC_ReadActualValues(void) {
    MC_ReadActualValues_create(this, sizeof(*this));
  } 
  ~MC_ReadActualValues(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Position(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Position(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_ReadActualValues> property_list[11];
  static IEC_Property_Range property_range_list[6];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_ReadActualValues* self = (MC_ReadActualValues*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_ReadActualValues* self = (MC_ReadActualValues*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_ReadActualValues_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_ReadSetDriveValues {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Enable;
  IEC_BOOL Valid;
  IEC_BOOL Busy;
  IEC_BOOL Error;
  IEC_WORD ErrorID;
  IEC_DINT Position;
  IEC_DINT Velocity;
  IEC_DINT Acceleration;
  IEC_DINT Jerk;

  // this param is padding for function block, sizeof : 40, dsize : 36, align : 8
  uint8_t __padding[4];

  static bool __s_has_MC_ReadSetDriveValues_on_copy;
  MC_ReadSetDriveValues& operator=(MC_ReadSetDriveValues&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Jerk = other.Jerk;
    Error = other.Error;
    Valid = other.Valid;
    Enable = other.Enable;
    native = other.native;
    ErrorID = other.ErrorID;
    Position = other.Position;
    Velocity = other.Velocity;
    Acceleration = other.Acceleration;
    return *this;
  }
  MC_ReadSetDriveValues& operator=(const MC_ReadSetDriveValues& other) {
    if (__s_has_MC_ReadSetDriveValues_on_copy) {
      MC_ReadSetDriveValues_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Jerk = other.Jerk;
      Error = other.Error;
      Valid = other.Valid;
      Enable = other.Enable;
      ErrorID = other.ErrorID;
      Position = other.Position;
      Velocity = other.Velocity;
      Acceleration = other.Acceleration;
    }
    return *this;
  }

  MC_ReadSetDriveValues(MC_ReadSetDriveValues&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Jerk = other.Jerk;
    Error = other.Error;
    Valid = other.Valid;
    Enable = other.Enable;
    native = other.native;
    ErrorID = other.ErrorID;
    Position = other.Position;
    Velocity = other.Velocity;
    Acceleration = other.Acceleration;
  }
  MC_ReadSetDriveValues(const MC_ReadSetDriveValues& other) : MC_ReadSetDriveValues() {
    if (__s_has_MC_ReadSetDriveValues_on_copy) {
      MC_ReadSetDriveValues_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Jerk = other.Jerk;
      Error = other.Error;
      Valid = other.Valid;
      Enable = other.Enable;
      ErrorID = other.ErrorID;
      Position = other.Position;
      Velocity = other.Velocity;
      Acceleration = other.Acceleration;
    }
  }

  MC_ReadSetDriveValues(void) {
    MC_ReadSetDriveValues_create(this, sizeof(*this));
  } 
  ~MC_ReadSetDriveValues(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Position(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Position(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_ReadSetDriveValues> property_list[11];
  static IEC_Property_Range property_range_list[6];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_ReadSetDriveValues* self = (MC_ReadSetDriveValues*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_ReadSetDriveValues* self = (MC_ReadSetDriveValues*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_ReadSetDriveValues_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_ReadSetValues {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Enable;
  IEC_BOOL Valid;
  IEC_BOOL Busy;
  IEC_BOOL Error;
  IEC_WORD ErrorID;
  IEC_LREAL Position;
  IEC_LREAL Velocity;
  IEC_LREAL Acceleration;
  IEC_LREAL Jerk;

  // this function block, sizeof : 56, dsize : 56, align : 8

  static bool __s_has_MC_ReadSetValues_on_copy;
  MC_ReadSetValues& operator=(MC_ReadSetValues&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Jerk = other.Jerk;
    Error = other.Error;
    Valid = other.Valid;
    Enable = other.Enable;
    native = other.native;
    ErrorID = other.ErrorID;
    Position = other.Position;
    Velocity = other.Velocity;
    Acceleration = other.Acceleration;
    return *this;
  }
  MC_ReadSetValues& operator=(const MC_ReadSetValues& other) {
    if (__s_has_MC_ReadSetValues_on_copy) {
      MC_ReadSetValues_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Jerk = other.Jerk;
      Error = other.Error;
      Valid = other.Valid;
      Enable = other.Enable;
      ErrorID = other.ErrorID;
      Position = other.Position;
      Velocity = other.Velocity;
      Acceleration = other.Acceleration;
    }
    return *this;
  }

  MC_ReadSetValues(MC_ReadSetValues&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Jerk = other.Jerk;
    Error = other.Error;
    Valid = other.Valid;
    Enable = other.Enable;
    native = other.native;
    ErrorID = other.ErrorID;
    Position = other.Position;
    Velocity = other.Velocity;
    Acceleration = other.Acceleration;
  }
  MC_ReadSetValues(const MC_ReadSetValues& other) : MC_ReadSetValues() {
    if (__s_has_MC_ReadSetValues_on_copy) {
      MC_ReadSetValues_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Jerk = other.Jerk;
      Error = other.Error;
      Valid = other.Valid;
      Enable = other.Enable;
      ErrorID = other.ErrorID;
      Position = other.Position;
      Velocity = other.Velocity;
      Acceleration = other.Acceleration;
    }
  }

  MC_ReadSetValues(void) {
    MC_ReadSetValues_create(this, sizeof(*this));
  } 
  ~MC_ReadSetValues(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Position(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Position(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_ReadSetValues> property_list[11];
  static IEC_Property_Range property_range_list[6];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_ReadSetValues* self = (MC_ReadSetValues*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_ReadSetValues* self = (MC_ReadSetValues*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_ReadSetValues_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct ZMC_ChangeGearingRatio {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL bExecute;
  IEC_UDINT dwRatioTechUnitsDenom;
  IEC_DINT iRatioTechUnitsNum;
  IEC_LREAL fPositionPeriod;
  IEC_INT iMovementType;
  IEC_BOOL bDone;
  IEC_BOOL bBusy;
  IEC_BOOL bError;
  IEC_WORD nErrorID;

  // this function block, sizeof : 40, dsize : 40, align : 8

  static bool __s_has_ZMC_ChangeGearingRatio_on_copy;
  ZMC_ChangeGearingRatio& operator=(ZMC_ChangeGearingRatio&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    bBusy = other.bBusy;
    bDone = other.bDone;
    bError = other.bError;
    native = other.native;
    bExecute = other.bExecute;
    nErrorID = other.nErrorID;
    iMovementType = other.iMovementType;
    fPositionPeriod = other.fPositionPeriod;
    iRatioTechUnitsNum = other.iRatioTechUnitsNum;
    dwRatioTechUnitsDenom = other.dwRatioTechUnitsDenom;
    return *this;
  }
  ZMC_ChangeGearingRatio& operator=(const ZMC_ChangeGearingRatio& other) {
    if (__s_has_ZMC_ChangeGearingRatio_on_copy) {
      ZMC_ChangeGearingRatio_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      bBusy = other.bBusy;
      bDone = other.bDone;
      bError = other.bError;
      bExecute = other.bExecute;
      nErrorID = other.nErrorID;
      iMovementType = other.iMovementType;
      fPositionPeriod = other.fPositionPeriod;
      iRatioTechUnitsNum = other.iRatioTechUnitsNum;
      dwRatioTechUnitsDenom = other.dwRatioTechUnitsDenom;
    }
    return *this;
  }

  ZMC_ChangeGearingRatio(ZMC_ChangeGearingRatio&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    bBusy = other.bBusy;
    bDone = other.bDone;
    bError = other.bError;
    native = other.native;
    bExecute = other.bExecute;
    nErrorID = other.nErrorID;
    iMovementType = other.iMovementType;
    fPositionPeriod = other.fPositionPeriod;
    iRatioTechUnitsNum = other.iRatioTechUnitsNum;
    dwRatioTechUnitsDenom = other.dwRatioTechUnitsDenom;
  }
  ZMC_ChangeGearingRatio(const ZMC_ChangeGearingRatio& other) : ZMC_ChangeGearingRatio() {
    if (__s_has_ZMC_ChangeGearingRatio_on_copy) {
      ZMC_ChangeGearingRatio_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      bBusy = other.bBusy;
      bDone = other.bDone;
      bError = other.bError;
      bExecute = other.bExecute;
      nErrorID = other.nErrorID;
      iMovementType = other.iMovementType;
      fPositionPeriod = other.fPositionPeriod;
      iRatioTechUnitsNum = other.iRatioTechUnitsNum;
      dwRatioTechUnitsDenom = other.dwRatioTechUnitsDenom;
    }
  }

  ZMC_ChangeGearingRatio(void) {
    ZMC_ChangeGearingRatio_create(this, sizeof(*this));
  } 
  ~ZMC_ChangeGearingRatio(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bExecute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_dwRatioTechUnitsDenom(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_iRatioTechUnitsNum(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_fPositionPeriod(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_iMovementType(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bDone(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bBusy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bError(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_nErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bExecute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_dwRatioTechUnitsDenom(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_iRatioTechUnitsNum(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_fPositionPeriod(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_iMovementType(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bDone(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bBusy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_nErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<ZMC_ChangeGearingRatio> property_list[11];
  static IEC_Property_Range property_range_list[8];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    ZMC_ChangeGearingRatio* self = (ZMC_ChangeGearingRatio*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      ZMC_ChangeGearingRatio* self = (ZMC_ChangeGearingRatio*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define ZMC_ChangeGearingRatio_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct ZMC_CheckLimits {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL bEnable;
  IEC_BOOL bCheckVel;
  IEC_BOOL bCheckAccDec;
  IEC_BOOL bBusy;
  IEC_BOOL bError;
  IEC_WORD iErrorID;
  IEC_BOOL bLimitsExceeded;

  // this param is padding for function block, sizeof : 24, dsize : 21, align : 8
  uint8_t __padding[3];

  static bool __s_has_ZMC_CheckLimits_on_copy;
  ZMC_CheckLimits& operator=(ZMC_CheckLimits&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    bBusy = other.bBusy;
    bError = other.bError;
    native = other.native;
    bEnable = other.bEnable;
    iErrorID = other.iErrorID;
    bCheckVel = other.bCheckVel;
    bCheckAccDec = other.bCheckAccDec;
    bLimitsExceeded = other.bLimitsExceeded;
    return *this;
  }
  ZMC_CheckLimits& operator=(const ZMC_CheckLimits& other) {
    if (__s_has_ZMC_CheckLimits_on_copy) {
      ZMC_CheckLimits_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      bBusy = other.bBusy;
      bError = other.bError;
      bEnable = other.bEnable;
      iErrorID = other.iErrorID;
      bCheckVel = other.bCheckVel;
      bCheckAccDec = other.bCheckAccDec;
      bLimitsExceeded = other.bLimitsExceeded;
    }
    return *this;
  }

  ZMC_CheckLimits(ZMC_CheckLimits&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    bBusy = other.bBusy;
    bError = other.bError;
    native = other.native;
    bEnable = other.bEnable;
    iErrorID = other.iErrorID;
    bCheckVel = other.bCheckVel;
    bCheckAccDec = other.bCheckAccDec;
    bLimitsExceeded = other.bLimitsExceeded;
  }
  ZMC_CheckLimits(const ZMC_CheckLimits& other) : ZMC_CheckLimits() {
    if (__s_has_ZMC_CheckLimits_on_copy) {
      ZMC_CheckLimits_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      bBusy = other.bBusy;
      bError = other.bError;
      bEnable = other.bEnable;
      iErrorID = other.iErrorID;
      bCheckVel = other.bCheckVel;
      bCheckAccDec = other.bCheckAccDec;
      bLimitsExceeded = other.bLimitsExceeded;
    }
  }

  ZMC_CheckLimits(void) {
    ZMC_CheckLimits_create(this, sizeof(*this));
  } 
  ~ZMC_CheckLimits(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bEnable(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bCheckVel(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bCheckAccDec(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bBusy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bError(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_iErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bLimitsExceeded(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bEnable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bCheckVel(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bCheckAccDec(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bBusy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_iErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bLimitsExceeded(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<ZMC_CheckLimits> property_list[9];
  static IEC_Property_Range property_range_list[8];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    ZMC_CheckLimits* self = (ZMC_CheckLimits*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      ZMC_CheckLimits* self = (ZMC_CheckLimits*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define ZMC_CheckLimits_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct ZMC_ControlAxisByPos {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_INT iStatus;
  IEC_BOOL bEnable;
  IEC_BOOL bAvoidGaps;
  IEC_LREAL fSetPosition;
  IEC_LREAL fGapVelocity;
  IEC_LREAL fGapAcceleration;
  IEC_LREAL fGapDeceleration;
  IEC_LREAL fGapJerk;
  IEC_BOOL bBusy;
  IEC_BOOL bCommandAborted;
  IEC_BOOL bError;
  IEC_INT iErrorID;
  IEC_BOOL bStopIpo;

  // this param is padding for function block, sizeof : 64, dsize : 63, align : 8
  uint8_t __padding[1];

  static bool __s_has_ZMC_ControlAxisByPos_on_copy;
  ZMC_ControlAxisByPos& operator=(ZMC_ControlAxisByPos&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    bBusy = other.bBusy;
    bError = other.bError;
    native = other.native;
    bEnable = other.bEnable;
    iStatus = other.iStatus;
    bStopIpo = other.bStopIpo;
    fGapJerk = other.fGapJerk;
    iErrorID = other.iErrorID;
    bAvoidGaps = other.bAvoidGaps;
    fGapVelocity = other.fGapVelocity;
    fSetPosition = other.fSetPosition;
    bCommandAborted = other.bCommandAborted;
    fGapAcceleration = other.fGapAcceleration;
    fGapDeceleration = other.fGapDeceleration;
    return *this;
  }
  ZMC_ControlAxisByPos& operator=(const ZMC_ControlAxisByPos& other) {
    if (__s_has_ZMC_ControlAxisByPos_on_copy) {
      ZMC_ControlAxisByPos_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      bBusy = other.bBusy;
      bError = other.bError;
      bEnable = other.bEnable;
      iStatus = other.iStatus;
      bStopIpo = other.bStopIpo;
      fGapJerk = other.fGapJerk;
      iErrorID = other.iErrorID;
      bAvoidGaps = other.bAvoidGaps;
      fGapVelocity = other.fGapVelocity;
      fSetPosition = other.fSetPosition;
      bCommandAborted = other.bCommandAborted;
      fGapAcceleration = other.fGapAcceleration;
      fGapDeceleration = other.fGapDeceleration;
    }
    return *this;
  }

  ZMC_ControlAxisByPos(ZMC_ControlAxisByPos&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    bBusy = other.bBusy;
    bError = other.bError;
    native = other.native;
    bEnable = other.bEnable;
    iStatus = other.iStatus;
    bStopIpo = other.bStopIpo;
    fGapJerk = other.fGapJerk;
    iErrorID = other.iErrorID;
    bAvoidGaps = other.bAvoidGaps;
    fGapVelocity = other.fGapVelocity;
    fSetPosition = other.fSetPosition;
    bCommandAborted = other.bCommandAborted;
    fGapAcceleration = other.fGapAcceleration;
    fGapDeceleration = other.fGapDeceleration;
  }
  ZMC_ControlAxisByPos(const ZMC_ControlAxisByPos& other) : ZMC_ControlAxisByPos() {
    if (__s_has_ZMC_ControlAxisByPos_on_copy) {
      ZMC_ControlAxisByPos_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      bBusy = other.bBusy;
      bError = other.bError;
      bEnable = other.bEnable;
      iStatus = other.iStatus;
      bStopIpo = other.bStopIpo;
      fGapJerk = other.fGapJerk;
      iErrorID = other.iErrorID;
      bAvoidGaps = other.bAvoidGaps;
      fGapVelocity = other.fGapVelocity;
      fSetPosition = other.fSetPosition;
      bCommandAborted = other.bCommandAborted;
      fGapAcceleration = other.fGapAcceleration;
      fGapDeceleration = other.fGapDeceleration;
    }
  }

  ZMC_ControlAxisByPos(void) {
    ZMC_ControlAxisByPos_create(this, sizeof(*this));
  } 
  ~ZMC_ControlAxisByPos(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_iStatus(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bEnable(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bAvoidGaps(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_fSetPosition(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_fGapVelocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_fGapAcceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_fGapDeceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_fGapJerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bBusy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bCommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bError(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_iErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bStopIpo(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_iStatus(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bEnable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bAvoidGaps(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_fSetPosition(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_fGapVelocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_fGapAcceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_fGapDeceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_fGapJerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bBusy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bCommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_iErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bStopIpo(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<ZMC_ControlAxisByPos> property_list[15];
  static IEC_Property_Range property_range_list[9];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    ZMC_ControlAxisByPos* self = (ZMC_ControlAxisByPos*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      ZMC_ControlAxisByPos* self = (ZMC_ControlAxisByPos*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define ZMC_ControlAxisByPos_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct ZMC_ControlAxisByPosVel {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_INT iStatus;
  IEC_BOOL bEnable;
  IEC_BOOL bAvoidGaps;
  IEC_LREAL fSetPosition;
  IEC_LREAL fSetVelocity;
  IEC_LREAL fGapVelocity;
  IEC_LREAL fGapAcceleration;
  IEC_LREAL fGapDeceleration;
  IEC_LREAL fGapJerk;
  IEC_BOOL bBusy;
  IEC_BOOL bCommandAborted;
  IEC_BOOL bError;
  IEC_INT iErrorID;
  IEC_BOOL bStopIpo;

  // this param is padding for function block, sizeof : 72, dsize : 71, align : 8
  uint8_t __padding[1];

  static bool __s_has_ZMC_ControlAxisByPosVel_on_copy;
  ZMC_ControlAxisByPosVel& operator=(ZMC_ControlAxisByPosVel&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    bBusy = other.bBusy;
    bError = other.bError;
    native = other.native;
    bEnable = other.bEnable;
    iStatus = other.iStatus;
    bStopIpo = other.bStopIpo;
    fGapJerk = other.fGapJerk;
    iErrorID = other.iErrorID;
    bAvoidGaps = other.bAvoidGaps;
    fGapVelocity = other.fGapVelocity;
    fSetPosition = other.fSetPosition;
    fSetVelocity = other.fSetVelocity;
    bCommandAborted = other.bCommandAborted;
    fGapAcceleration = other.fGapAcceleration;
    fGapDeceleration = other.fGapDeceleration;
    return *this;
  }
  ZMC_ControlAxisByPosVel& operator=(const ZMC_ControlAxisByPosVel& other) {
    if (__s_has_ZMC_ControlAxisByPosVel_on_copy) {
      ZMC_ControlAxisByPosVel_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      bBusy = other.bBusy;
      bError = other.bError;
      bEnable = other.bEnable;
      iStatus = other.iStatus;
      bStopIpo = other.bStopIpo;
      fGapJerk = other.fGapJerk;
      iErrorID = other.iErrorID;
      bAvoidGaps = other.bAvoidGaps;
      fGapVelocity = other.fGapVelocity;
      fSetPosition = other.fSetPosition;
      fSetVelocity = other.fSetVelocity;
      bCommandAborted = other.bCommandAborted;
      fGapAcceleration = other.fGapAcceleration;
      fGapDeceleration = other.fGapDeceleration;
    }
    return *this;
  }

  ZMC_ControlAxisByPosVel(ZMC_ControlAxisByPosVel&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    bBusy = other.bBusy;
    bError = other.bError;
    native = other.native;
    bEnable = other.bEnable;
    iStatus = other.iStatus;
    bStopIpo = other.bStopIpo;
    fGapJerk = other.fGapJerk;
    iErrorID = other.iErrorID;
    bAvoidGaps = other.bAvoidGaps;
    fGapVelocity = other.fGapVelocity;
    fSetPosition = other.fSetPosition;
    fSetVelocity = other.fSetVelocity;
    bCommandAborted = other.bCommandAborted;
    fGapAcceleration = other.fGapAcceleration;
    fGapDeceleration = other.fGapDeceleration;
  }
  ZMC_ControlAxisByPosVel(const ZMC_ControlAxisByPosVel& other) : ZMC_ControlAxisByPosVel() {
    if (__s_has_ZMC_ControlAxisByPosVel_on_copy) {
      ZMC_ControlAxisByPosVel_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      bBusy = other.bBusy;
      bError = other.bError;
      bEnable = other.bEnable;
      iStatus = other.iStatus;
      bStopIpo = other.bStopIpo;
      fGapJerk = other.fGapJerk;
      iErrorID = other.iErrorID;
      bAvoidGaps = other.bAvoidGaps;
      fGapVelocity = other.fGapVelocity;
      fSetPosition = other.fSetPosition;
      fSetVelocity = other.fSetVelocity;
      bCommandAborted = other.bCommandAborted;
      fGapAcceleration = other.fGapAcceleration;
      fGapDeceleration = other.fGapDeceleration;
    }
  }

  ZMC_ControlAxisByPosVel(void) {
    ZMC_ControlAxisByPosVel_create(this, sizeof(*this));
  } 
  ~ZMC_ControlAxisByPosVel(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_iStatus(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bEnable(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bAvoidGaps(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_fSetPosition(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_fSetVelocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_fGapVelocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_fGapAcceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_fGapDeceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_fGapJerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bBusy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bCommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bError(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_iErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bStopIpo(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_iStatus(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bEnable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bAvoidGaps(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_fSetPosition(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_fSetVelocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_fGapVelocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_fGapAcceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_fGapDeceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_fGapJerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bBusy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bCommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_iErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bStopIpo(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<ZMC_ControlAxisByPosVel> property_list[16];
  static IEC_Property_Range property_range_list[9];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    ZMC_ControlAxisByPosVel* self = (ZMC_ControlAxisByPosVel*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      ZMC_ControlAxisByPosVel* self = (ZMC_ControlAxisByPosVel*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define ZMC_ControlAxisByPosVel_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct ZMC_ControlAxisByVel {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_INT iStatus;
  IEC_BOOL bEnable;
  IEC_BOOL bAvoidGaps;
  IEC_LREAL fSetVelocity;
  IEC_LREAL fGapAcceleration;
  IEC_LREAL fGapDeceleration;
  IEC_LREAL fGapJerk;
  IEC_BOOL bBusy;
  IEC_BOOL bCommandAborted;
  IEC_BOOL bError;
  IEC_INT iErrorID;
  IEC_BOOL bStopIpo;

  // this param is padding for function block, sizeof : 56, dsize : 55, align : 8
  uint8_t __padding[1];

  static bool __s_has_ZMC_ControlAxisByVel_on_copy;
  ZMC_ControlAxisByVel& operator=(ZMC_ControlAxisByVel&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    bBusy = other.bBusy;
    bError = other.bError;
    native = other.native;
    bEnable = other.bEnable;
    iStatus = other.iStatus;
    bStopIpo = other.bStopIpo;
    fGapJerk = other.fGapJerk;
    iErrorID = other.iErrorID;
    bAvoidGaps = other.bAvoidGaps;
    fSetVelocity = other.fSetVelocity;
    bCommandAborted = other.bCommandAborted;
    fGapAcceleration = other.fGapAcceleration;
    fGapDeceleration = other.fGapDeceleration;
    return *this;
  }
  ZMC_ControlAxisByVel& operator=(const ZMC_ControlAxisByVel& other) {
    if (__s_has_ZMC_ControlAxisByVel_on_copy) {
      ZMC_ControlAxisByVel_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      bBusy = other.bBusy;
      bError = other.bError;
      bEnable = other.bEnable;
      iStatus = other.iStatus;
      bStopIpo = other.bStopIpo;
      fGapJerk = other.fGapJerk;
      iErrorID = other.iErrorID;
      bAvoidGaps = other.bAvoidGaps;
      fSetVelocity = other.fSetVelocity;
      bCommandAborted = other.bCommandAborted;
      fGapAcceleration = other.fGapAcceleration;
      fGapDeceleration = other.fGapDeceleration;
    }
    return *this;
  }

  ZMC_ControlAxisByVel(ZMC_ControlAxisByVel&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    bBusy = other.bBusy;
    bError = other.bError;
    native = other.native;
    bEnable = other.bEnable;
    iStatus = other.iStatus;
    bStopIpo = other.bStopIpo;
    fGapJerk = other.fGapJerk;
    iErrorID = other.iErrorID;
    bAvoidGaps = other.bAvoidGaps;
    fSetVelocity = other.fSetVelocity;
    bCommandAborted = other.bCommandAborted;
    fGapAcceleration = other.fGapAcceleration;
    fGapDeceleration = other.fGapDeceleration;
  }
  ZMC_ControlAxisByVel(const ZMC_ControlAxisByVel& other) : ZMC_ControlAxisByVel() {
    if (__s_has_ZMC_ControlAxisByVel_on_copy) {
      ZMC_ControlAxisByVel_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      bBusy = other.bBusy;
      bError = other.bError;
      bEnable = other.bEnable;
      iStatus = other.iStatus;
      bStopIpo = other.bStopIpo;
      fGapJerk = other.fGapJerk;
      iErrorID = other.iErrorID;
      bAvoidGaps = other.bAvoidGaps;
      fSetVelocity = other.fSetVelocity;
      bCommandAborted = other.bCommandAborted;
      fGapAcceleration = other.fGapAcceleration;
      fGapDeceleration = other.fGapDeceleration;
    }
  }

  ZMC_ControlAxisByVel(void) {
    ZMC_ControlAxisByVel_create(this, sizeof(*this));
  } 
  ~ZMC_ControlAxisByVel(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_iStatus(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bEnable(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bAvoidGaps(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_fSetVelocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_fGapAcceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_fGapDeceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_fGapJerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bBusy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bCommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bError(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_iErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bStopIpo(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_iStatus(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bEnable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bAvoidGaps(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_fSetVelocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_fGapAcceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_fGapDeceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_fGapJerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bBusy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bCommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_iErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bStopIpo(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<ZMC_ControlAxisByVel> property_list[14];
  static IEC_Property_Range property_range_list[9];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    ZMC_ControlAxisByVel* self = (ZMC_ControlAxisByVel*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      ZMC_ControlAxisByVel* self = (ZMC_ControlAxisByVel*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define ZMC_ControlAxisByVel_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct ZMC_ReadErrorMsg {
  IEC_ULINT native;
  IEC_BOOL Enable;
  IEC_WORD Index;
  IEC_String<IEC_CHAR, 80> ErrorMsg;
  IEC_BOOL Valid;
  IEC_BOOL Busy;

  // this param is padding for function block, sizeof : 96, dsize : 95, align : 8
  uint8_t __padding[1];

  static bool __s_has_ZMC_ReadErrorMsg_on_copy;
  ZMC_ReadErrorMsg& operator=(ZMC_ReadErrorMsg&& other) noexcept {
    this->deinit_();
    Busy = other.Busy;
    Index = other.Index;
    Valid = other.Valid;
    Enable = other.Enable;
    native = other.native;
    ErrorMsg = other.ErrorMsg;
    return *this;
  }
  ZMC_ReadErrorMsg& operator=(const ZMC_ReadErrorMsg& other) {
    if (__s_has_ZMC_ReadErrorMsg_on_copy) {
      ZMC_ReadErrorMsg_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Busy = other.Busy;
      Index = other.Index;
      Valid = other.Valid;
      Enable = other.Enable;
      ErrorMsg = other.ErrorMsg;
    }
    return *this;
  }

  ZMC_ReadErrorMsg(ZMC_ReadErrorMsg&& other) noexcept {
    Busy = other.Busy;
    Index = other.Index;
    Valid = other.Valid;
    Enable = other.Enable;
    native = other.native;
    ErrorMsg = other.ErrorMsg;
  }
  ZMC_ReadErrorMsg(const ZMC_ReadErrorMsg& other) : ZMC_ReadErrorMsg() {
    if (__s_has_ZMC_ReadErrorMsg_on_copy) {
      ZMC_ReadErrorMsg_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Busy = other.Busy;
      Index = other.Index;
      Valid = other.Valid;
      Enable = other.Enable;
      ErrorMsg = other.ErrorMsg;
    }
  }

  ZMC_ReadErrorMsg(void) {
    ZMC_ReadErrorMsg_create(this, sizeof(*this));
  } 
  ~ZMC_ReadErrorMsg(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Index(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorMsg(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Index(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorMsg(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<ZMC_ReadErrorMsg> property_list[6];
  static IEC_Property_Range property_range_list[4];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    ZMC_ReadErrorMsg* self = (ZMC_ReadErrorMsg*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      ZMC_ReadErrorMsg* self = (ZMC_ReadErrorMsg*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define ZMC_ReadErrorMsg_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct ZMC_ReadAxisMappingID {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL Enable;
  IEC_BOOL Valid;
  IEC_BOOL Busy;
  IEC_BOOL Error;
  IEC_WORD ErrorID;
  IEC_WORD MappingID;

  // this param is padding for function block, sizeof : 24, dsize : 20, align : 8
  uint8_t __padding[4];

  static bool __s_has_ZMC_ReadAxisMappingID_on_copy;
  ZMC_ReadAxisMappingID& operator=(ZMC_ReadAxisMappingID&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Error = other.Error;
    Valid = other.Valid;
    Enable = other.Enable;
    native = other.native;
    ErrorID = other.ErrorID;
    MappingID = other.MappingID;
    return *this;
  }
  ZMC_ReadAxisMappingID& operator=(const ZMC_ReadAxisMappingID& other) {
    if (__s_has_ZMC_ReadAxisMappingID_on_copy) {
      ZMC_ReadAxisMappingID_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Error = other.Error;
      Valid = other.Valid;
      Enable = other.Enable;
      ErrorID = other.ErrorID;
      MappingID = other.MappingID;
    }
    return *this;
  }

  ZMC_ReadAxisMappingID(ZMC_ReadAxisMappingID&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Error = other.Error;
    Valid = other.Valid;
    Enable = other.Enable;
    native = other.native;
    ErrorID = other.ErrorID;
    MappingID = other.MappingID;
  }
  ZMC_ReadAxisMappingID(const ZMC_ReadAxisMappingID& other) : ZMC_ReadAxisMappingID() {
    if (__s_has_ZMC_ReadAxisMappingID_on_copy) {
      ZMC_ReadAxisMappingID_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Error = other.Error;
      Valid = other.Valid;
      Enable = other.Enable;
      ErrorID = other.ErrorID;
      MappingID = other.MappingID;
    }
  }

  ZMC_ReadAxisMappingID(void) {
    ZMC_ReadAxisMappingID_create(this, sizeof(*this));
  } 
  ~ZMC_ReadAxisMappingID(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_MappingID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_MappingID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<ZMC_ReadAxisMappingID> property_list[8];
  static IEC_Property_Range property_range_list[5];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    ZMC_ReadAxisMappingID* self = (ZMC_ReadAxisMappingID*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      ZMC_ReadAxisMappingID* self = (ZMC_ReadAxisMappingID*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define ZMC_ReadAxisMappingID_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct ZMC_SetMovementType {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL bExecute;
  IEC_INT iMovementType;
  IEC_LREAL fPositionPeriod;
  IEC_BOOL bDone;
  IEC_BOOL bError;
  IEC_WORD eErrorID;

  // this param is padding for function block, sizeof : 32, dsize : 28, align : 8
  uint8_t __padding[4];

  static bool __s_has_ZMC_SetMovementType_on_copy;
  ZMC_SetMovementType& operator=(ZMC_SetMovementType&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    bDone = other.bDone;
    bError = other.bError;
    native = other.native;
    bExecute = other.bExecute;
    eErrorID = other.eErrorID;
    iMovementType = other.iMovementType;
    fPositionPeriod = other.fPositionPeriod;
    return *this;
  }
  ZMC_SetMovementType& operator=(const ZMC_SetMovementType& other) {
    if (__s_has_ZMC_SetMovementType_on_copy) {
      ZMC_SetMovementType_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      bDone = other.bDone;
      bError = other.bError;
      bExecute = other.bExecute;
      eErrorID = other.eErrorID;
      iMovementType = other.iMovementType;
      fPositionPeriod = other.fPositionPeriod;
    }
    return *this;
  }

  ZMC_SetMovementType(ZMC_SetMovementType&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    bDone = other.bDone;
    bError = other.bError;
    native = other.native;
    bExecute = other.bExecute;
    eErrorID = other.eErrorID;
    iMovementType = other.iMovementType;
    fPositionPeriod = other.fPositionPeriod;
  }
  ZMC_SetMovementType(const ZMC_SetMovementType& other) : ZMC_SetMovementType() {
    if (__s_has_ZMC_SetMovementType_on_copy) {
      ZMC_SetMovementType_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      bDone = other.bDone;
      bError = other.bError;
      bExecute = other.bExecute;
      eErrorID = other.eErrorID;
      iMovementType = other.iMovementType;
      fPositionPeriod = other.fPositionPeriod;
    }
  }

  ZMC_SetMovementType(void) {
    ZMC_SetMovementType_create(this, sizeof(*this));
  } 
  ~ZMC_SetMovementType(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bExecute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_iMovementType(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_fPositionPeriod(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bDone(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bError(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_eErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bExecute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_iMovementType(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_fPositionPeriod(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bDone(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_eErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<ZMC_SetMovementType> property_list[8];
  static IEC_Property_Range property_range_list[6];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    ZMC_SetMovementType* self = (ZMC_SetMovementType*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      ZMC_SetMovementType* self = (ZMC_SetMovementType*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define ZMC_SetMovementType_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct ZMC_SetRampType {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL bExecute;
  IEC_INT eRampType;
  IEC_BOOL bDone;
  IEC_BOOL bError;
  IEC_WORD eErrorID;

  // this param is padding for function block, sizeof : 24, dsize : 20, align : 8
  uint8_t __padding[4];

  static bool __s_has_ZMC_SetRampType_on_copy;
  ZMC_SetRampType& operator=(ZMC_SetRampType&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    bDone = other.bDone;
    bError = other.bError;
    native = other.native;
    bExecute = other.bExecute;
    eErrorID = other.eErrorID;
    eRampType = other.eRampType;
    return *this;
  }
  ZMC_SetRampType& operator=(const ZMC_SetRampType& other) {
    if (__s_has_ZMC_SetRampType_on_copy) {
      ZMC_SetRampType_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      bDone = other.bDone;
      bError = other.bError;
      bExecute = other.bExecute;
      eErrorID = other.eErrorID;
      eRampType = other.eRampType;
    }
    return *this;
  }

  ZMC_SetRampType(ZMC_SetRampType&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    bDone = other.bDone;
    bError = other.bError;
    native = other.native;
    bExecute = other.bExecute;
    eErrorID = other.eErrorID;
    eRampType = other.eRampType;
  }
  ZMC_SetRampType(const ZMC_SetRampType& other) : ZMC_SetRampType() {
    if (__s_has_ZMC_SetRampType_on_copy) {
      ZMC_SetRampType_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      bDone = other.bDone;
      bError = other.bError;
      bExecute = other.bExecute;
      eErrorID = other.eErrorID;
      eRampType = other.eRampType;
    }
  }

  ZMC_SetRampType(void) {
    ZMC_SetRampType_create(this, sizeof(*this));
  } 
  ~ZMC_SetRampType(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bExecute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_eRampType(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bDone(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bError(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_eErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bExecute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_eRampType(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bDone(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_eErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<ZMC_SetRampType> property_list[7];
  static IEC_Property_Range property_range_list[5];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    ZMC_SetRampType* self = (ZMC_SetRampType*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      ZMC_SetRampType* self = (ZMC_SetRampType*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define ZMC_SetRampType_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct ZMC_SetSoftwareLimits {
  IEC_ULINT native;
  AXIS_REF Axis;
  IEC_BOOL bExecute;
  IEC_BOOL SWL_Activated;
  IEC_LREAL SWL_Positive;
  IEC_LREAL SWL_Negative;
  IEC_BOOL SWL_Error_Decelerate;
  IEC_LREAL SWL_Error_Deceleration;
  IEC_LREAL SWL_Error_MaxDistance;
  IEC_BOOL bDone;
  IEC_BOOL bError;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 64, dsize : 60, align : 8
  uint8_t __padding[4];

  static bool __s_has_ZMC_SetSoftwareLimits_on_copy;
  ZMC_SetSoftwareLimits& operator=(ZMC_SetSoftwareLimits&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    bDone = other.bDone;
    bError = other.bError;
    native = other.native;
    ErrorID = other.ErrorID;
    bExecute = other.bExecute;
    SWL_Negative = other.SWL_Negative;
    SWL_Positive = other.SWL_Positive;
    SWL_Activated = other.SWL_Activated;
    SWL_Error_Decelerate = other.SWL_Error_Decelerate;
    SWL_Error_MaxDistance = other.SWL_Error_MaxDistance;
    SWL_Error_Deceleration = other.SWL_Error_Deceleration;
    return *this;
  }
  ZMC_SetSoftwareLimits& operator=(const ZMC_SetSoftwareLimits& other) {
    if (__s_has_ZMC_SetSoftwareLimits_on_copy) {
      ZMC_SetSoftwareLimits_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      bDone = other.bDone;
      bError = other.bError;
      ErrorID = other.ErrorID;
      bExecute = other.bExecute;
      SWL_Negative = other.SWL_Negative;
      SWL_Positive = other.SWL_Positive;
      SWL_Activated = other.SWL_Activated;
      SWL_Error_Decelerate = other.SWL_Error_Decelerate;
      SWL_Error_MaxDistance = other.SWL_Error_MaxDistance;
      SWL_Error_Deceleration = other.SWL_Error_Deceleration;
    }
    return *this;
  }

  ZMC_SetSoftwareLimits(ZMC_SetSoftwareLimits&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    bDone = other.bDone;
    bError = other.bError;
    native = other.native;
    ErrorID = other.ErrorID;
    bExecute = other.bExecute;
    SWL_Negative = other.SWL_Negative;
    SWL_Positive = other.SWL_Positive;
    SWL_Activated = other.SWL_Activated;
    SWL_Error_Decelerate = other.SWL_Error_Decelerate;
    SWL_Error_MaxDistance = other.SWL_Error_MaxDistance;
    SWL_Error_Deceleration = other.SWL_Error_Deceleration;
  }
  ZMC_SetSoftwareLimits(const ZMC_SetSoftwareLimits& other) : ZMC_SetSoftwareLimits() {
    if (__s_has_ZMC_SetSoftwareLimits_on_copy) {
      ZMC_SetSoftwareLimits_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      bDone = other.bDone;
      bError = other.bError;
      ErrorID = other.ErrorID;
      bExecute = other.bExecute;
      SWL_Negative = other.SWL_Negative;
      SWL_Positive = other.SWL_Positive;
      SWL_Activated = other.SWL_Activated;
      SWL_Error_Decelerate = other.SWL_Error_Decelerate;
      SWL_Error_MaxDistance = other.SWL_Error_MaxDistance;
      SWL_Error_Deceleration = other.SWL_Error_Deceleration;
    }
  }

  ZMC_SetSoftwareLimits(void) {
    ZMC_SetSoftwareLimits_create(this, sizeof(*this));
  } 
  ~ZMC_SetSoftwareLimits(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bExecute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_SWL_Activated(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_SWL_Positive(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_SWL_Negative(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_SWL_Error_Decelerate(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_SWL_Error_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_SWL_Error_MaxDistance(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bDone(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_bError(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bExecute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_SWL_Activated(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_SWL_Positive(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_SWL_Negative(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_SWL_Error_Decelerate(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_SWL_Error_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_SWL_Error_MaxDistance(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bDone(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_bError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<ZMC_SetSoftwareLimits> property_list[12];
  static IEC_Property_Range property_range_list[10];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    ZMC_SetSoftwareLimits* self = (ZMC_SetSoftwareLimits*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      ZMC_SetSoftwareLimits* self = (ZMC_SetSoftwareLimits*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define ZMC_SetSoftwareLimits_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct AXIS_GROUP_REF {
  IEC_ULINT native;
  IEC_INT id;

  // this param is padding for function block, sizeof : 16, dsize : 10, align : 8
  uint8_t __padding[6];

  static bool __s_has_AXIS_GROUP_REF_on_copy;
  AXIS_GROUP_REF& operator=(AXIS_GROUP_REF&& other) noexcept {
    this->deinit_();
    id = other.id;
    native = other.native;
    return *this;
  }
  AXIS_GROUP_REF& operator=(const AXIS_GROUP_REF& other) {
    if (__s_has_AXIS_GROUP_REF_on_copy) {
      AXIS_GROUP_REF_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      id = other.id;
    }
    return *this;
  }

  AXIS_GROUP_REF(AXIS_GROUP_REF&& other) noexcept {
    id = other.id;
    native = other.native;
  }
  AXIS_GROUP_REF(const AXIS_GROUP_REF& other) : AXIS_GROUP_REF() {
    if (__s_has_AXIS_GROUP_REF_on_copy) {
      AXIS_GROUP_REF_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      id = other.id;
    }
  }

  AXIS_GROUP_REF(void) {
    AXIS_GROUP_REF_create(this, sizeof(*this));
  } 
  ~AXIS_GROUP_REF(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_id(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_id(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<AXIS_GROUP_REF> property_list[2];
  static IEC_Property_Range property_range_list[2];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    AXIS_GROUP_REF* self = (AXIS_GROUP_REF*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      AXIS_GROUP_REF* self = (AXIS_GROUP_REF*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define AXIS_GROUP_REF_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MC_AddAxisToGroup {
  IEC_ULINT native;
  AXIS_GROUP_REF AxisGroup;
  AXIS_REF Axis;
  IEC_BOOL Execute;
  IEC_BOOL Done;
  IEC_BOOL Busy;
  IEC_BOOL Error;
  IEC_WORD ErrorID;

  // this param is padding for function block, sizeof : 40, dsize : 34, align : 8
  uint8_t __padding[6];

  static bool __s_has_MC_AddAxisToGroup_on_copy;
  MC_AddAxisToGroup& operator=(MC_AddAxisToGroup&& other) noexcept {
    this->deinit_();
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    AxisGroup = other.AxisGroup;
    return *this;
  }
  MC_AddAxisToGroup& operator=(const MC_AddAxisToGroup& other) {
    if (__s_has_MC_AddAxisToGroup_on_copy) {
      MC_AddAxisToGroup_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      AxisGroup = other.AxisGroup;
    }
    return *this;
  }

  MC_AddAxisToGroup(MC_AddAxisToGroup&& other) noexcept {
    Axis = other.Axis;
    other.Axis = nullptr;
    Busy = other.Busy;
    Done = other.Done;
    Error = other.Error;
    native = other.native;
    ErrorID = other.ErrorID;
    Execute = other.Execute;
    AxisGroup = other.AxisGroup;
  }
  MC_AddAxisToGroup(const MC_AddAxisToGroup& other) : MC_AddAxisToGroup() {
    if (__s_has_MC_AddAxisToGroup_on_copy) {
      MC_AddAxisToGroup_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
      Axis = other.Axis;
      Busy = other.Busy;
      Done = other.Done;
      Error = other.Error;
      ErrorID = other.ErrorID;
      Execute = other.Execute;
      AxisGroup = other.AxisGroup;
    }
  }

  MC_AddAxisToGroup(void) {
    MC_AddAxisToGroup_create(this, sizeof(*this));
  } 
  ~MC_AddAxisToGroup(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_AxisGroup(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_AxisGroup(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MC_AddAxisToGroup> property_list[8];
  static IEC_Property_Range property_range_list[5];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MC_AddAxisToGroup* self = (MC_AddAxisToGroup*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MC_AddAxisToGroup* self = (MC_AddAxisToGroup*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MC_AddAxisToGroup_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct MODBUS_SLAVE_IO {
  IEC_ULINT native;

  // this function block, sizeof : 8, dsize : 8, align : 8

  static bool __s_has_MODBUS_SLAVE_IO_on_copy;
  MODBUS_SLAVE_IO& operator=(MODBUS_SLAVE_IO&& other) noexcept {
    this->deinit_();
    native = other.native;
    return *this;
  }
  MODBUS_SLAVE_IO& operator=(const MODBUS_SLAVE_IO& other) {
    if (__s_has_MODBUS_SLAVE_IO_on_copy) {
      MODBUS_SLAVE_IO_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
    }
    return *this;
  }

  MODBUS_SLAVE_IO(MODBUS_SLAVE_IO&& other) noexcept {
    native = other.native;
  }
  MODBUS_SLAVE_IO(const MODBUS_SLAVE_IO& other) : MODBUS_SLAVE_IO() {
    if (__s_has_MODBUS_SLAVE_IO_on_copy) {
      MODBUS_SLAVE_IO_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
    }
  }

  MODBUS_SLAVE_IO(void) {
    MODBUS_SLAVE_IO_create(this, sizeof(*this));
  } 
  ~MODBUS_SLAVE_IO(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<MODBUS_SLAVE_IO> property_list[1];
  static IEC_Property_Range property_range_list[1];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    MODBUS_SLAVE_IO* self = (MODBUS_SLAVE_IO*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      MODBUS_SLAVE_IO* self = (MODBUS_SLAVE_IO*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define MODBUS_SLAVE_IO_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct LOCAL_EQEP {
  IEC_ULINT native;

  // this function block, sizeof : 8, dsize : 8, align : 8

  static bool __s_has_LOCAL_EQEP_on_copy;
  LOCAL_EQEP& operator=(LOCAL_EQEP&& other) noexcept {
    this->deinit_();
    native = other.native;
    return *this;
  }
  LOCAL_EQEP& operator=(const LOCAL_EQEP& other) {
    if (__s_has_LOCAL_EQEP_on_copy) {
      LOCAL_EQEP_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
    }
    return *this;
  }

  LOCAL_EQEP(LOCAL_EQEP&& other) noexcept {
    native = other.native;
  }
  LOCAL_EQEP(const LOCAL_EQEP& other) : LOCAL_EQEP() {
    if (__s_has_LOCAL_EQEP_on_copy) {
      LOCAL_EQEP_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
    }
  }

  LOCAL_EQEP(void) {
    LOCAL_EQEP_create(this, sizeof(*this));
  } 
  ~LOCAL_EQEP(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<LOCAL_EQEP> property_list[1];
  static IEC_Property_Range property_range_list[1];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    LOCAL_EQEP* self = (LOCAL_EQEP*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      LOCAL_EQEP* self = (LOCAL_EQEP*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define LOCAL_EQEP_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct LOCAL_IO {
  IEC_ULINT native;

  // this function block, sizeof : 8, dsize : 8, align : 8

  static bool __s_has_LOCAL_IO_on_copy;
  LOCAL_IO& operator=(LOCAL_IO&& other) noexcept {
    this->deinit_();
    native = other.native;
    return *this;
  }
  LOCAL_IO& operator=(const LOCAL_IO& other) {
    if (__s_has_LOCAL_IO_on_copy) {
      LOCAL_IO_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
    }
    return *this;
  }

  LOCAL_IO(LOCAL_IO&& other) noexcept {
    native = other.native;
  }
  LOCAL_IO(const LOCAL_IO& other) : LOCAL_IO() {
    if (__s_has_LOCAL_IO_on_copy) {
      LOCAL_IO_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
    }
  }

  LOCAL_IO(void) {
    LOCAL_IO_create(this, sizeof(*this));
  } 
  ~LOCAL_IO(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<LOCAL_IO> property_list[1];
  static IEC_Property_Range property_range_list[1];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    LOCAL_IO* self = (LOCAL_IO*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      LOCAL_IO* self = (LOCAL_IO*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define LOCAL_IO_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct LOCAL_PWM {
  IEC_ULINT native;

  // this function block, sizeof : 8, dsize : 8, align : 8

  static bool __s_has_LOCAL_PWM_on_copy;
  LOCAL_PWM& operator=(LOCAL_PWM&& other) noexcept {
    this->deinit_();
    native = other.native;
    return *this;
  }
  LOCAL_PWM& operator=(const LOCAL_PWM& other) {
    if (__s_has_LOCAL_PWM_on_copy) {
      LOCAL_PWM_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
    }
    return *this;
  }

  LOCAL_PWM(LOCAL_PWM&& other) noexcept {
    native = other.native;
  }
  LOCAL_PWM(const LOCAL_PWM& other) : LOCAL_PWM() {
    if (__s_has_LOCAL_PWM_on_copy) {
      LOCAL_PWM_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
    }
  }

  LOCAL_PWM(void) {
    LOCAL_PWM_create(this, sizeof(*this));
  } 
  ~LOCAL_PWM(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<LOCAL_PWM> property_list[1];
  static IEC_Property_Range property_range_list[1];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    LOCAL_PWM* self = (LOCAL_PWM*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      LOCAL_PWM* self = (LOCAL_PWM*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define LOCAL_PWM_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct CANOPEN_MASTER_IO {
  IEC_ULINT native;

  // this function block, sizeof : 8, dsize : 8, align : 8

  static bool __s_has_CANOPEN_MASTER_IO_on_copy;
  CANOPEN_MASTER_IO& operator=(CANOPEN_MASTER_IO&& other) noexcept {
    this->deinit_();
    native = other.native;
    return *this;
  }
  CANOPEN_MASTER_IO& operator=(const CANOPEN_MASTER_IO& other) {
    if (__s_has_CANOPEN_MASTER_IO_on_copy) {
      CANOPEN_MASTER_IO_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
    }
    return *this;
  }

  CANOPEN_MASTER_IO(CANOPEN_MASTER_IO&& other) noexcept {
    native = other.native;
  }
  CANOPEN_MASTER_IO(const CANOPEN_MASTER_IO& other) : CANOPEN_MASTER_IO() {
    if (__s_has_CANOPEN_MASTER_IO_on_copy) {
      CANOPEN_MASTER_IO_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
    }
  }

  CANOPEN_MASTER_IO(void) {
    CANOPEN_MASTER_IO_create(this, sizeof(*this));
  } 
  ~CANOPEN_MASTER_IO(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<CANOPEN_MASTER_IO> property_list[1];
  static IEC_Property_Range property_range_list[1];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    CANOPEN_MASTER_IO* self = (CANOPEN_MASTER_IO*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      CANOPEN_MASTER_IO* self = (CANOPEN_MASTER_IO*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define CANOPEN_MASTER_IO_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct CANOPEN_SLAVE_IO {
  IEC_ULINT native;

  // this function block, sizeof : 8, dsize : 8, align : 8

  static bool __s_has_CANOPEN_SLAVE_IO_on_copy;
  CANOPEN_SLAVE_IO& operator=(CANOPEN_SLAVE_IO&& other) noexcept {
    this->deinit_();
    native = other.native;
    return *this;
  }
  CANOPEN_SLAVE_IO& operator=(const CANOPEN_SLAVE_IO& other) {
    if (__s_has_CANOPEN_SLAVE_IO_on_copy) {
      CANOPEN_SLAVE_IO_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
    }
    return *this;
  }

  CANOPEN_SLAVE_IO(CANOPEN_SLAVE_IO&& other) noexcept {
    native = other.native;
  }
  CANOPEN_SLAVE_IO(const CANOPEN_SLAVE_IO& other) : CANOPEN_SLAVE_IO() {
    if (__s_has_CANOPEN_SLAVE_IO_on_copy) {
      CANOPEN_SLAVE_IO_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
    }
  }

  CANOPEN_SLAVE_IO(void) {
    CANOPEN_SLAVE_IO_create(this, sizeof(*this));
  } 
  ~CANOPEN_SLAVE_IO(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<CANOPEN_SLAVE_IO> property_list[1];
  static IEC_Property_Range property_range_list[1];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    CANOPEN_SLAVE_IO* self = (CANOPEN_SLAVE_IO*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      CANOPEN_SLAVE_IO* self = (CANOPEN_SLAVE_IO*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define CANOPEN_SLAVE_IO_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct EIP_SLAVE_IO {
  IEC_ULINT native;

  // this function block, sizeof : 8, dsize : 8, align : 8

  static bool __s_has_EIP_SLAVE_IO_on_copy;
  EIP_SLAVE_IO& operator=(EIP_SLAVE_IO&& other) noexcept {
    this->deinit_();
    native = other.native;
    return *this;
  }
  EIP_SLAVE_IO& operator=(const EIP_SLAVE_IO& other) {
    if (__s_has_EIP_SLAVE_IO_on_copy) {
      EIP_SLAVE_IO_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
    }
    return *this;
  }

  EIP_SLAVE_IO(EIP_SLAVE_IO&& other) noexcept {
    native = other.native;
  }
  EIP_SLAVE_IO(const EIP_SLAVE_IO& other) : EIP_SLAVE_IO() {
    if (__s_has_EIP_SLAVE_IO_on_copy) {
      EIP_SLAVE_IO_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
    }
  }

  EIP_SLAVE_IO(void) {
    EIP_SLAVE_IO_create(this, sizeof(*this));
  } 
  ~EIP_SLAVE_IO(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<EIP_SLAVE_IO> property_list[1];
  static IEC_Property_Range property_range_list[1];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    EIP_SLAVE_IO* self = (EIP_SLAVE_IO*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      EIP_SLAVE_IO* self = (EIP_SLAVE_IO*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define EIP_SLAVE_IO_init_(p) (p)->init_() 
#pragma pack(push, AW_PLC_NATIVE_ALIGN)
struct OPCUA_IO {
  IEC_ULINT native;

  // this function block, sizeof : 8, dsize : 8, align : 8

  static bool __s_has_OPCUA_IO_on_copy;
  OPCUA_IO& operator=(OPCUA_IO&& other) noexcept {
    this->deinit_();
    native = other.native;
    return *this;
  }
  OPCUA_IO& operator=(const OPCUA_IO& other) {
    if (__s_has_OPCUA_IO_on_copy) {
      OPCUA_IO_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
    }
    return *this;
  }

  OPCUA_IO(OPCUA_IO&& other) noexcept {
    native = other.native;
  }
  OPCUA_IO(const OPCUA_IO& other) : OPCUA_IO() {
    if (__s_has_OPCUA_IO_on_copy) {
      OPCUA_IO_on_copy((void*)this, sizeof(*this), (void*)&other, sizeof(other));
    } else {
    }
  }

  OPCUA_IO(void) {
    OPCUA_IO_create(this, sizeof(*this));
  } 
  ~OPCUA_IO(void) {this->deinit_();}
  static void init_static_(void);
  void exec_(void);
  void init_(void);
  void deinit_(void);
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name);
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name);
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  bool get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj);
  bool set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj);
  static IEC_Property<OPCUA_IO> property_list[1];
  static IEC_Property_Range property_range_list[1];
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    OPCUA_IO* self = (OPCUA_IO*)iec_base;
    return (self->*(property_list[index_].get_))(sub_name, v_, NULL);
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    if (property_list[index_].set_ != nullptr) {
      OPCUA_IO* self = (OPCUA_IO*)iec_base;
      return (self->*(property_list[index_].set_))(sub_name, v_, NULL);
    } else {
      return false;
    }
  }
};
#pragma pack(pop)
#define OPCUA_IO_init_(p) (p)->init_() 
IEC_BOOL ComponentStatusChecker();
IEC_BOOL Get_AXIS_REF(IEC_UDINT masterNodeID, IEC_UDINT slaveNodeID, IEC_UDINT axisIndex, IEC_VarRef<IEC_UDINT> axisBlockID__, IEC_VarRef<AXIS_REF> resultAxis__);
IEC_BOOL TwoWord_From_REAL(IEC_REAL Data, IEC_WORD Fixed_Point, IEC_VarRef<IEC_WORD> L_Word__, IEC_VarRef<IEC_WORD> H_Word__, IEC_VarRef<IEC_WORD> N_Fixed_Point__);
IEC_BOOL TwoWord_From_UDINT(IEC_UDINT Data, IEC_VarRef<IEC_WORD> L_Word__, IEC_VarRef<IEC_WORD> H_Word__);
IEC_REAL TwoWord_To_REAL(IEC_WORD L_Word, IEC_WORD H_Word, IEC_WORD N_Fixed_Point);
IEC_UDINT TwoWord_To_UDINT(IEC_WORD L_Word, IEC_WORD H_Word);
IEC_INT ZMC_SetFreeEncoderPosition(AXIS_REF Axis, IEC_DINT diEncoderPosition);
IEC_DINT ZMC_Add(IEC_DINT IN1, IEC_DINT IN2);
IEC_DINT ZMC_GetVersion(IEC_DINT IN1);
struct Script_3: public IEC_Program {

  Script_3(void) {
  } 
  ~Script_3(void) {this->deinit_();}
  void exec_(void) override;
  void init_(void) override;
  void deinit_(void) override;
  bool save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) override;
  bool load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) override;
  bool get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) override;
  bool set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) override;
  static bool self_get_by_index_(void* iec_base, uint32_t index_, const char* sub_name, value_t * v_) {
    return false;
  }
  static bool self_set_by_index_(void* iec_base, uint32_t index_, const char* sub_name, const value_t * v_) {
    return false;
  }

  static Script_3* instance;
  static Script_3* create(void) {
    if (Script_3::instance == NULL) {
      Script_3::instance = new Script_3();
      Script_3::instance->ref_count = 1;
      IEC_PLC::instance()->add_program("Script_3", Script_3::instance);
    } else {
      Script_3::instance->ref_count++;
    }

    return Script_3::instance;
  }

  void unref(void) override {
    this->ref_count--;
    if(this->ref_count == 0) {
      IEC_PLC::instance()->remove_program("Script_3");
      assert(Script_3::instance == this);
      delete this;
      Script_3::instance = NULL;
    }
  }
};
#define Script_3_init_(p) (p)->init_() 
#define IEC_HAS_CONFIGURATIONS_ 1
#define IEC_MIN_INTERVAL_ 10000
#define IEC_RETAIN_DATA_SIZE_ 0
#define IEC_PERSISTENT_DATA_SIZE_ 0
