bool AXIS_BASE::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool AXIS_BASE::get_refAxisIO(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, refAxisIO);
    return true;
  } else if (*name_ != '^' || refAxisIO == NULL) { return false; }
  return true;
}
bool AXIS_BASE::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool AXIS_BASE::set_refAxisIO(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    refAxisIO = static_cast<VOID_ADR >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || refAxisIO == NULL) { return false; }

  return true;
}

IEC_Property<AXIS_BASE> AXIS_BASE::property_list[] = { 
  {"native", 6, "ULINT", &AXIS_BASE::get_native, &AXIS_BASE::set_native }, 
  {"refAxisIO", 9, "POINTER TO VOID_ADR", &AXIS_BASE::get_refAxisIO, &AXIS_BASE::set_refAxisIO }, 
};
IEC_Property_Range AXIS_BASE::property_range_list[] = { 
  {0, 1, 6 }, 
  {1, 1, 9 }, 
};

bool AXIS_BASE::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (refAxisIO != NULL)) {
  }
  return true;
}

bool AXIS_BASE::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (refAxisIO != NULL)) {
  }
  return true;
}

bool AXIS_BASE::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool AXIS_BASE::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_CAM_ID::get_pCT(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, pCT);
    return true;
  } else if (*name_ != '^' || pCT == NULL) { return false; }
  (void)obj;
  (void)name_;
  value_set_uint8(v_, (*(pCT)));
  return true;
}
bool MC_CAM_ID::get_Periodic(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Periodic)));
  return true;
}
bool MC_CAM_ID::get_MasterAbsolute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((MasterAbsolute)));
  return true;
}
bool MC_CAM_ID::get_SlaveAbsolute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((SlaveAbsolute)));
  return true;
}
bool MC_CAM_ID::get_StartMaster(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((StartMaster)));
  return true;
}
bool MC_CAM_ID::get_EndMaster(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((EndMaster)));
  return true;
}
bool MC_CAM_ID::get_StartSlave(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((StartSlave)));
  return true;
}
bool MC_CAM_ID::get_EndSlave(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((EndSlave)));
  return true;
}
bool MC_CAM_ID::get_byCompatibilityMode(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint8(v_, ((byCompatibilityMode)));
  return true;
}
bool MC_CAM_ID::set_pCT(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    pCT = static_cast<IEC_BYTE* >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || pCT == NULL) { return false; }

  (void)obj;
  (void)name_;
  *(pCT) = value_uint8(v_);
  return true;
}
bool MC_CAM_ID::set_Periodic(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Periodic) = value_bool(v_);
  return true;
}
bool MC_CAM_ID::set_MasterAbsolute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (MasterAbsolute) = value_bool(v_);
  return true;
}
bool MC_CAM_ID::set_SlaveAbsolute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (SlaveAbsolute) = value_bool(v_);
  return true;
}
bool MC_CAM_ID::set_StartMaster(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (StartMaster) = value_double(v_);
  return true;
}
bool MC_CAM_ID::set_EndMaster(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (EndMaster) = value_double(v_);
  return true;
}
bool MC_CAM_ID::set_StartSlave(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (StartSlave) = value_double(v_);
  return true;
}
bool MC_CAM_ID::set_EndSlave(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (EndSlave) = value_double(v_);
  return true;
}
bool MC_CAM_ID::set_byCompatibilityMode(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (byCompatibilityMode) = value_uint8(v_);
  return true;
}

IEC_Property<MC_CAM_ID> MC_CAM_ID::property_list[] = { 
  {"pCT", 3, "POINTER TO BYTE", &MC_CAM_ID::get_pCT, &MC_CAM_ID::set_pCT }, 
  {"EndSlave", 8, "LREAL", &MC_CAM_ID::get_EndSlave, &MC_CAM_ID::set_EndSlave }, 
  {"Periodic", 8, "BOOL", &MC_CAM_ID::get_Periodic, &MC_CAM_ID::set_Periodic }, 
  {"EndMaster", 9, "LREAL", &MC_CAM_ID::get_EndMaster, &MC_CAM_ID::set_EndMaster }, 
  {"StartSlave", 10, "LREAL", &MC_CAM_ID::get_StartSlave, &MC_CAM_ID::set_StartSlave }, 
  {"StartMaster", 11, "LREAL", &MC_CAM_ID::get_StartMaster, &MC_CAM_ID::set_StartMaster }, 
  {"SlaveAbsolute", 13, "BOOL", &MC_CAM_ID::get_SlaveAbsolute, &MC_CAM_ID::set_SlaveAbsolute }, 
  {"MasterAbsolute", 14, "BOOL", &MC_CAM_ID::get_MasterAbsolute, &MC_CAM_ID::set_MasterAbsolute }, 
  {"byCompatibilityMode", 19, "BYTE", &MC_CAM_ID::get_byCompatibilityMode, &MC_CAM_ID::set_byCompatibilityMode }, 
};
IEC_Property_Range MC_CAM_ID::property_range_list[] = { 
  {0, 1, 3 }, 
  {1, 2, 8 }, 
  {3, 1, 9 }, 
  {4, 1, 10 }, 
  {5, 1, 11 }, 
  {6, 1, 13 }, 
  {7, 1, 14 }, 
  {8, 1, 19 }, 
};

bool MC_CAM_ID::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((TRUE) && (pCT != NULL)) {
    st_ubjson_write_kv_uint8(writer_, "pCT", (*(pCT)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_bool(writer_, "Periodic", ((Periodic)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_bool(writer_, "MasterAbsolute", ((MasterAbsolute)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_bool(writer_, "SlaveAbsolute", ((SlaveAbsolute)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_double(writer_, "StartMaster", ((StartMaster)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_double(writer_, "EndMaster", ((EndMaster)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_double(writer_, "StartSlave", ((StartSlave)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_double(writer_, "EndSlave", ((EndSlave)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_uint8(writer_, "byCompatibilityMode", ((byCompatibilityMode)));
  }
  return true;
}

bool MC_CAM_ID::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((TRUE) && (pCT != NULL)) {
      if(conf_node_get_child_value(parent_, "pCT", &v_) == RET_OK)
        *(pCT) = value_uint8(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "Periodic", &v_) == RET_OK)
        (Periodic) = value_bool(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "MasterAbsolute", &v_) == RET_OK)
        (MasterAbsolute) = value_bool(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "SlaveAbsolute", &v_) == RET_OK)
        (SlaveAbsolute) = value_bool(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "StartMaster", &v_) == RET_OK)
        (StartMaster) = value_double(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "EndMaster", &v_) == RET_OK)
        (EndMaster) = value_double(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "StartSlave", &v_) == RET_OK)
        (StartSlave) = value_double(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "EndSlave", &v_) == RET_OK)
        (EndSlave) = value_double(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "byCompatibilityMode", &v_) == RET_OK)
        (byCompatibilityMode) = value_uint8(&v_);
  }
  return true;
}

bool MC_CAM_ID::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_CAM_ID::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool ZMC_CAMXYVA::get_dX(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((dX)));
  return true;
}
bool ZMC_CAMXYVA::get_dY(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((dY)));
  return true;
}
bool ZMC_CAMXYVA::get_dV(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((dV)));
  return true;
}
bool ZMC_CAMXYVA::get_dA(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((dA)));
  return true;
}
bool ZMC_CAMXYVA::set_dX(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (dX) = value_double(v_);
  return true;
}
bool ZMC_CAMXYVA::set_dY(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (dY) = value_double(v_);
  return true;
}
bool ZMC_CAMXYVA::set_dV(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (dV) = value_double(v_);
  return true;
}
bool ZMC_CAMXYVA::set_dA(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (dA) = value_double(v_);
  return true;
}

IEC_Property<ZMC_CAMXYVA> ZMC_CAMXYVA::property_list[] = { 
  {"dA", 2, "LREAL", &ZMC_CAMXYVA::get_dA, &ZMC_CAMXYVA::set_dA }, 
  {"dV", 2, "LREAL", &ZMC_CAMXYVA::get_dV, &ZMC_CAMXYVA::set_dV }, 
  {"dX", 2, "LREAL", &ZMC_CAMXYVA::get_dX, &ZMC_CAMXYVA::set_dX }, 
  {"dY", 2, "LREAL", &ZMC_CAMXYVA::get_dY, &ZMC_CAMXYVA::set_dY }, 
};
IEC_Property_Range ZMC_CAMXYVA::property_range_list[] = { 
  {0, 4, 2 }, 
};

bool ZMC_CAMXYVA::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((TRUE)) {
    st_ubjson_write_kv_double(writer_, "dX", ((dX)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_double(writer_, "dY", ((dY)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_double(writer_, "dV", ((dV)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_double(writer_, "dA", ((dA)));
  }
  return true;
}

bool ZMC_CAMXYVA::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "dX", &v_) == RET_OK)
        (dX) = value_double(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "dY", &v_) == RET_OK)
        (dY) = value_double(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "dV", &v_) == RET_OK)
        (dV) = value_double(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "dA", &v_) == RET_OK)
        (dA) = value_double(&v_);
  }
  return true;
}

bool ZMC_CAMXYVA::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool ZMC_CAMXYVA::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool ZMC_CAMTappet::get_ctt(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((ctt)));
  return true;
}
bool ZMC_CAMTappet::get_cta(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((cta)));
  return true;
}
bool ZMC_CAMTappet::get_dwDelay(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint32(v_, ((dwDelay)));
  return true;
}
bool ZMC_CAMTappet::get_dwDuration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint32(v_, ((dwDuration)));
  return true;
}
bool ZMC_CAMTappet::get_iGroupID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((iGroupID)));
  return true;
}
bool ZMC_CAMTappet::get_x(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((x)));
  return true;
}
bool ZMC_CAMTappet::get_dwActive(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint32(v_, ((dwActive)));
  return true;
}
bool ZMC_CAMTappet::set_ctt(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ctt) = (ZMC_CAMTAPPETTYPE)value_int16(v_);
  return true;
}
bool ZMC_CAMTappet::set_cta(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (cta) = (ZMC_CAMTAPPETACTION)value_int16(v_);
  return true;
}
bool ZMC_CAMTappet::set_dwDelay(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (dwDelay) = value_uint32(v_);
  return true;
}
bool ZMC_CAMTappet::set_dwDuration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (dwDuration) = value_uint32(v_);
  return true;
}
bool ZMC_CAMTappet::set_iGroupID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (iGroupID) = value_int16(v_);
  return true;
}
bool ZMC_CAMTappet::set_x(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (x) = value_double(v_);
  return true;
}
bool ZMC_CAMTappet::set_dwActive(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (dwActive) = value_uint32(v_);
  return true;
}

IEC_Property<ZMC_CAMTappet> ZMC_CAMTappet::property_list[] = { 
  {"x", 1, "LREAL", &ZMC_CAMTappet::get_x, &ZMC_CAMTappet::set_x }, 
  {"cta", 3, "INT", &ZMC_CAMTappet::get_cta, &ZMC_CAMTappet::set_cta }, 
  {"ctt", 3, "INT", &ZMC_CAMTappet::get_ctt, &ZMC_CAMTappet::set_ctt }, 
  {"dwDelay", 7, "DWORD", &ZMC_CAMTappet::get_dwDelay, &ZMC_CAMTappet::set_dwDelay }, 
  {"dwActive", 8, "DWORD", &ZMC_CAMTappet::get_dwActive, &ZMC_CAMTappet::set_dwActive }, 
  {"iGroupID", 8, "INT", &ZMC_CAMTappet::get_iGroupID, &ZMC_CAMTappet::set_iGroupID }, 
  {"dwDuration", 10, "DWORD", &ZMC_CAMTappet::get_dwDuration, &ZMC_CAMTappet::set_dwDuration }, 
};
IEC_Property_Range ZMC_CAMTappet::property_range_list[] = { 
  {0, 1, 1 }, 
  {1, 2, 3 }, 
  {3, 1, 7 }, 
  {4, 2, 8 }, 
  {6, 1, 10 }, 
};

bool ZMC_CAMTappet::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((TRUE)) {
    st_ubjson_write_kv_int16(writer_, "ctt", ((ctt)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_int16(writer_, "cta", ((cta)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_uint32(writer_, "dwDelay", ((dwDelay)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_uint32(writer_, "dwDuration", ((dwDuration)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_int16(writer_, "iGroupID", ((iGroupID)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_double(writer_, "x", ((x)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_uint32(writer_, "dwActive", ((dwActive)));
  }
  return true;
}

bool ZMC_CAMTappet::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "ctt", &v_) == RET_OK)
        (ctt) = (ZMC_CAMTAPPETTYPE)value_int16(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "cta", &v_) == RET_OK)
        (cta) = (ZMC_CAMTAPPETACTION)value_int16(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "dwDelay", &v_) == RET_OK)
        (dwDelay) = value_uint32(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "dwDuration", &v_) == RET_OK)
        (dwDuration) = value_uint32(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "iGroupID", &v_) == RET_OK)
        (iGroupID) = value_int16(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "x", &v_) == RET_OK)
        (x) = value_double(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "dwActive", &v_) == RET_OK)
        (dwActive) = value_uint32(&v_);
  }
  return true;
}

bool ZMC_CAMTappet::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool ZMC_CAMTappet::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool ZMC_CAM_TABLE::get_wCamStructID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((wCamStructID)));
  return true;
}
bool ZMC_CAM_TABLE::get_byType(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((byType)));
  return true;
}
bool ZMC_CAM_TABLE::get_byVarType(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint8(v_, ((byVarType)));
  return true;
}
bool ZMC_CAM_TABLE::get_xStart(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((xStart)));
  return true;
}
bool ZMC_CAM_TABLE::get_xEnd(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((xEnd)));
  return true;
}
bool ZMC_CAM_TABLE::get_nElements(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((nElements)));
  return true;
}
bool ZMC_CAM_TABLE::get_nTappets(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((nTappets)));
  return true;
}
bool ZMC_CAM_TABLE::get_pce(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, pce);
    return true;
  } else if (*name_ != '^' || pce == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return pce->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_CAM_TABLE::get_pt(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, pt);
    return true;
  } else if (*name_ != '^' || pt == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return pt->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_CAM_TABLE::get_dwTappetActiveBits(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint32(v_, ((dwTappetActiveBits)));
  return true;
}
bool ZMC_CAM_TABLE::get_strCAMName(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_str(v_, ((strCAMName)).get());
  return true;
}
bool ZMC_CAM_TABLE::get_byInterpolationQuality(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint8(v_, ((byInterpolationQuality)));
  return true;
}
bool ZMC_CAM_TABLE::get_byCompatibilityMode(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint8(v_, ((byCompatibilityMode)));
  return true;
}
bool ZMC_CAM_TABLE::get_bChangedOnline(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bChangedOnline)));
  return true;
}
bool ZMC_CAM_TABLE::get_xPartofLM(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((xPartofLM)));
  return true;
}
bool ZMC_CAM_TABLE::set_wCamStructID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (wCamStructID) = value_uint16(v_);
  return true;
}
bool ZMC_CAM_TABLE::set_byType(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (byType) = (ZMC_CAM_TYPE)value_int16(v_);
  return true;
}
bool ZMC_CAM_TABLE::set_byVarType(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (byVarType) = value_uint8(v_);
  return true;
}
bool ZMC_CAM_TABLE::set_xStart(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (xStart) = value_double(v_);
  return true;
}
bool ZMC_CAM_TABLE::set_xEnd(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (xEnd) = value_double(v_);
  return true;
}
bool ZMC_CAM_TABLE::set_nElements(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (nElements) = value_int16(v_);
  return true;
}
bool ZMC_CAM_TABLE::set_nTappets(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (nTappets) = value_int16(v_);
  return true;
}
bool ZMC_CAM_TABLE::set_pce(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    pce = static_cast<ZMC_CAMXYVA* >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || pce == NULL) { return false; }

  return pce->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_CAM_TABLE::set_pt(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    pt = static_cast<ZMC_CAMTappet* >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || pt == NULL) { return false; }

  return pt->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_CAM_TABLE::set_dwTappetActiveBits(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (dwTappetActiveBits) = value_uint32(v_);
  return true;
}
bool ZMC_CAM_TABLE::set_strCAMName(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (strCAMName) = value_str(v_);
  return true;
}
bool ZMC_CAM_TABLE::set_byInterpolationQuality(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (byInterpolationQuality) = value_uint8(v_);
  return true;
}
bool ZMC_CAM_TABLE::set_byCompatibilityMode(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (byCompatibilityMode) = value_uint8(v_);
  return true;
}
bool ZMC_CAM_TABLE::set_bChangedOnline(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bChangedOnline) = value_bool(v_);
  return true;
}
bool ZMC_CAM_TABLE::set_xPartofLM(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (xPartofLM) = value_bool(v_);
  return true;
}

IEC_Property<ZMC_CAM_TABLE> ZMC_CAM_TABLE::property_list[] = { 
  {"pt", 2, "POINTER TO ZMC_CAMTappet", &ZMC_CAM_TABLE::get_pt, &ZMC_CAM_TABLE::set_pt }, 
  {"pce", 3, "POINTER TO ZMC_CAMXYVA", &ZMC_CAM_TABLE::get_pce, &ZMC_CAM_TABLE::set_pce }, 
  {"xEnd", 4, "LREAL", &ZMC_CAM_TABLE::get_xEnd, &ZMC_CAM_TABLE::set_xEnd }, 
  {"byType", 6, "INT", &ZMC_CAM_TABLE::get_byType, &ZMC_CAM_TABLE::set_byType }, 
  {"xStart", 6, "LREAL", &ZMC_CAM_TABLE::get_xStart, &ZMC_CAM_TABLE::set_xStart }, 
  {"nTappets", 8, "INT", &ZMC_CAM_TABLE::get_nTappets, &ZMC_CAM_TABLE::set_nTappets }, 
  {"byVarType", 9, "BYTE", &ZMC_CAM_TABLE::get_byVarType, &ZMC_CAM_TABLE::set_byVarType }, 
  {"nElements", 9, "INT", &ZMC_CAM_TABLE::get_nElements, &ZMC_CAM_TABLE::set_nElements }, 
  {"xPartofLM", 9, "BOOL", &ZMC_CAM_TABLE::get_xPartofLM, &ZMC_CAM_TABLE::set_xPartofLM }, 
  {"strCAMName", 10, "STRING", &ZMC_CAM_TABLE::get_strCAMName, &ZMC_CAM_TABLE::set_strCAMName }, 
  {"wCamStructID", 12, "WORD", &ZMC_CAM_TABLE::get_wCamStructID, &ZMC_CAM_TABLE::set_wCamStructID }, 
  {"bChangedOnline", 14, "BOOL", &ZMC_CAM_TABLE::get_bChangedOnline, &ZMC_CAM_TABLE::set_bChangedOnline }, 
  {"dwTappetActiveBits", 18, "DWORD", &ZMC_CAM_TABLE::get_dwTappetActiveBits, &ZMC_CAM_TABLE::set_dwTappetActiveBits }, 
  {"byCompatibilityMode", 19, "BYTE", &ZMC_CAM_TABLE::get_byCompatibilityMode, &ZMC_CAM_TABLE::set_byCompatibilityMode }, 
  {"byInterpolationQuality", 22, "BYTE", &ZMC_CAM_TABLE::get_byInterpolationQuality, &ZMC_CAM_TABLE::set_byInterpolationQuality }, 
};
IEC_Property_Range ZMC_CAM_TABLE::property_range_list[] = { 
  {0, 1, 2 }, 
  {1, 1, 3 }, 
  {2, 1, 4 }, 
  {3, 2, 6 }, 
  {5, 1, 8 }, 
  {6, 3, 9 }, 
  {9, 1, 10 }, 
  {10, 1, 12 }, 
  {11, 1, 14 }, 
  {12, 1, 18 }, 
  {13, 1, 19 }, 
  {14, 1, 22 }, 
};

bool ZMC_CAM_TABLE::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((TRUE)) {
    st_ubjson_write_kv_uint16(writer_, "wCamStructID", ((wCamStructID)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_int16(writer_, "byType", ((byType)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_uint8(writer_, "byVarType", ((byVarType)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_double(writer_, "xStart", ((xStart)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_double(writer_, "xEnd", ((xEnd)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_int16(writer_, "nElements", ((nElements)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_int16(writer_, "nTappets", ((nTappets)));
  }
  if((TRUE) && (pce != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "pce");
      pce->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((TRUE) && (pt != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "pt");
      pt->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((TRUE)) {
    st_ubjson_write_kv_uint32(writer_, "dwTappetActiveBits", ((dwTappetActiveBits)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_str(writer_, "strCAMName", ((strCAMName)).get());
  }
  if((TRUE)) {
    st_ubjson_write_kv_uint8(writer_, "byInterpolationQuality", ((byInterpolationQuality)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_uint8(writer_, "byCompatibilityMode", ((byCompatibilityMode)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_bool(writer_, "bChangedOnline", ((bChangedOnline)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_bool(writer_, "xPartofLM", ((xPartofLM)));
  }
  return true;
}

bool ZMC_CAM_TABLE::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "wCamStructID", &v_) == RET_OK)
        (wCamStructID) = value_uint16(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "byType", &v_) == RET_OK)
        (byType) = (ZMC_CAM_TYPE)value_int16(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "byVarType", &v_) == RET_OK)
        (byVarType) = value_uint8(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "xStart", &v_) == RET_OK)
        (xStart) = value_double(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "xEnd", &v_) == RET_OK)
        (xEnd) = value_double(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "nElements", &v_) == RET_OK)
        (nElements) = value_int16(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "nTappets", &v_) == RET_OK)
        (nTappets) = value_int16(&v_);
  }
  if((TRUE) && (pce != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "pce");
      if (sub != nullptr) pce->load_(sub, type_, nullptr);
  }
  if((TRUE) && (pt != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "pt");
      if (sub != nullptr) pt->load_(sub, type_, nullptr);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "dwTappetActiveBits", &v_) == RET_OK)
        (dwTappetActiveBits) = value_uint32(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "strCAMName", &v_) == RET_OK)
        (strCAMName) = value_str(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "byInterpolationQuality", &v_) == RET_OK)
        (byInterpolationQuality) = value_uint8(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "byCompatibilityMode", &v_) == RET_OK)
        (byCompatibilityMode) = value_uint8(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "bChangedOnline", &v_) == RET_OK)
        (bChangedOnline) = value_bool(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "xPartofLM", &v_) == RET_OK)
        (xPartofLM) = value_bool(&v_);
  }
  return true;
}

bool ZMC_CAM_TABLE::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool ZMC_CAM_TABLE::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_CAMSWITCH_TR::get_TrackNumber(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((TrackNumber)));
  return true;
}
bool MC_CAMSWITCH_TR::get_FirstOnPosition(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((FirstOnPosition)));
  return true;
}
bool MC_CAMSWITCH_TR::get_LastOnPosition(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((LastOnPosition)));
  return true;
}
bool MC_CAMSWITCH_TR::get_AxisDirection(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((AxisDirection)));
  return true;
}
bool MC_CAMSWITCH_TR::get_CamSwitchMode(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((CamSwitchMode)));
  return true;
}
bool MC_CAMSWITCH_TR::get_Duration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((Duration)));
  return true;
}
bool MC_CAMSWITCH_TR::get_bOn(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bOn)));
  return true;
}
bool MC_CAMSWITCH_TR::get_CounterOff(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((CounterOff)));
  return true;
}
bool MC_CAMSWITCH_TR::set_TrackNumber(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (TrackNumber) = value_int16(v_);
  return true;
}
bool MC_CAMSWITCH_TR::set_FirstOnPosition(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (FirstOnPosition) = value_double(v_);
  return true;
}
bool MC_CAMSWITCH_TR::set_LastOnPosition(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (LastOnPosition) = value_double(v_);
  return true;
}
bool MC_CAMSWITCH_TR::set_AxisDirection(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (AxisDirection) = value_int16(v_);
  return true;
}
bool MC_CAMSWITCH_TR::set_CamSwitchMode(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (CamSwitchMode) = value_int16(v_);
  return true;
}
bool MC_CAMSWITCH_TR::set_Duration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Duration) = value_uint64(v_);
  return true;
}
bool MC_CAMSWITCH_TR::set_bOn(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bOn) = value_bool(v_);
  return true;
}
bool MC_CAMSWITCH_TR::set_CounterOff(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (CounterOff) = value_int16(v_);
  return true;
}

IEC_Property<MC_CAMSWITCH_TR> MC_CAMSWITCH_TR::property_list[] = { 
  {"bOn", 3, "BOOL", &MC_CAMSWITCH_TR::get_bOn, &MC_CAMSWITCH_TR::set_bOn }, 
  {"Duration", 8, "TIME", &MC_CAMSWITCH_TR::get_Duration, &MC_CAMSWITCH_TR::set_Duration }, 
  {"CounterOff", 10, "INT", &MC_CAMSWITCH_TR::get_CounterOff, &MC_CAMSWITCH_TR::set_CounterOff }, 
  {"TrackNumber", 11, "INT", &MC_CAMSWITCH_TR::get_TrackNumber, &MC_CAMSWITCH_TR::set_TrackNumber }, 
  {"AxisDirection", 13, "INT", &MC_CAMSWITCH_TR::get_AxisDirection, &MC_CAMSWITCH_TR::set_AxisDirection }, 
  {"CamSwitchMode", 13, "INT", &MC_CAMSWITCH_TR::get_CamSwitchMode, &MC_CAMSWITCH_TR::set_CamSwitchMode }, 
  {"LastOnPosition", 14, "LREAL", &MC_CAMSWITCH_TR::get_LastOnPosition, &MC_CAMSWITCH_TR::set_LastOnPosition }, 
  {"FirstOnPosition", 15, "LREAL", &MC_CAMSWITCH_TR::get_FirstOnPosition, &MC_CAMSWITCH_TR::set_FirstOnPosition }, 
};
IEC_Property_Range MC_CAMSWITCH_TR::property_range_list[] = { 
  {0, 1, 3 }, 
  {1, 1, 8 }, 
  {2, 1, 10 }, 
  {3, 1, 11 }, 
  {4, 2, 13 }, 
  {6, 1, 14 }, 
  {7, 1, 15 }, 
};

bool MC_CAMSWITCH_TR::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((TRUE)) {
    st_ubjson_write_kv_int16(writer_, "TrackNumber", ((TrackNumber)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_double(writer_, "FirstOnPosition", ((FirstOnPosition)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_double(writer_, "LastOnPosition", ((LastOnPosition)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_int16(writer_, "AxisDirection", ((AxisDirection)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_int16(writer_, "CamSwitchMode", ((CamSwitchMode)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_uint64(writer_, "Duration", ((Duration)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_bool(writer_, "bOn", ((bOn)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_int16(writer_, "CounterOff", ((CounterOff)));
  }
  return true;
}

bool MC_CAMSWITCH_TR::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "TrackNumber", &v_) == RET_OK)
        (TrackNumber) = value_int16(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "FirstOnPosition", &v_) == RET_OK)
        (FirstOnPosition) = value_double(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "LastOnPosition", &v_) == RET_OK)
        (LastOnPosition) = value_double(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "AxisDirection", &v_) == RET_OK)
        (AxisDirection) = value_int16(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "CamSwitchMode", &v_) == RET_OK)
        (CamSwitchMode) = value_int16(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "Duration", &v_) == RET_OK)
        (Duration) = value_uint64(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "bOn", &v_) == RET_OK)
        (bOn) = value_bool(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "CounterOff", &v_) == RET_OK)
        (CounterOff) = value_int16(&v_);
  }
  return true;
}

bool MC_CAMSWITCH_TR::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_CAMSWITCH_TR::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_CAMSWITCH_REF::get_NoOfSwitches(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint8(v_, ((NoOfSwitches)));
  return true;
}
bool MC_CAMSWITCH_REF::get_CamSwitchPtr(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, CamSwitchPtr);
    return true;
  } else if (*name_ != '^' || CamSwitchPtr == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return CamSwitchPtr->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_CAMSWITCH_REF::set_NoOfSwitches(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (NoOfSwitches) = value_uint8(v_);
  return true;
}
bool MC_CAMSWITCH_REF::set_CamSwitchPtr(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    CamSwitchPtr = static_cast<MC_CAMSWITCH_TR* >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || CamSwitchPtr == NULL) { return false; }

  return CamSwitchPtr->set_(tk_str_skip_object_prefix(name_), v_, obj);
}

IEC_Property<MC_CAMSWITCH_REF> MC_CAMSWITCH_REF::property_list[] = { 
  {"CamSwitchPtr", 12, "POINTER TO MC_CAMSWITCH_TR", &MC_CAMSWITCH_REF::get_CamSwitchPtr, &MC_CAMSWITCH_REF::set_CamSwitchPtr }, 
  {"NoOfSwitches", 12, "BYTE", &MC_CAMSWITCH_REF::get_NoOfSwitches, &MC_CAMSWITCH_REF::set_NoOfSwitches }, 
};
IEC_Property_Range MC_CAMSWITCH_REF::property_range_list[] = { 
  {0, 2, 12 }, 
};

bool MC_CAMSWITCH_REF::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((TRUE)) {
    st_ubjson_write_kv_uint8(writer_, "NoOfSwitches", ((NoOfSwitches)));
  }
  if((TRUE) && (CamSwitchPtr != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "CamSwitchPtr");
      CamSwitchPtr->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  return true;
}

bool MC_CAMSWITCH_REF::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "NoOfSwitches", &v_) == RET_OK)
        (NoOfSwitches) = value_uint8(&v_);
  }
  if((TRUE) && (CamSwitchPtr != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "CamSwitchPtr");
      if (sub != nullptr) CamSwitchPtr->load_(sub, type_, nullptr);
  }
  return true;
}

bool MC_CAMSWITCH_REF::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_CAMSWITCH_REF::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool ZMC_TA::get_delta_time(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((delta_time)));
  return true;
}
bool ZMC_TA::get_acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((acceleration)));
  return true;
}
bool ZMC_TA::set_delta_time(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (delta_time) = value_uint64(v_);
  return true;
}
bool ZMC_TA::set_acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (acceleration) = value_double(v_);
  return true;
}

IEC_Property<ZMC_TA> ZMC_TA::property_list[] = { 
  {"delta_time", 10, "TIME", &ZMC_TA::get_delta_time, &ZMC_TA::set_delta_time }, 
  {"acceleration", 12, "LREAL", &ZMC_TA::get_acceleration, &ZMC_TA::set_acceleration }, 
};
IEC_Property_Range ZMC_TA::property_range_list[] = { 
  {0, 1, 10 }, 
  {1, 1, 12 }, 
};

bool ZMC_TA::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((TRUE)) {
    st_ubjson_write_kv_uint64(writer_, "delta_time", ((delta_time)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_double(writer_, "acceleration", ((acceleration)));
  }
  return true;
}

bool ZMC_TA::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "delta_time", &v_) == RET_OK)
        (delta_time) = value_uint64(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "acceleration", &v_) == RET_OK)
        (acceleration) = value_double(&v_);
  }
  return true;
}

bool ZMC_TA::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool ZMC_TA::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_TA_REF::get_Number_of_pairs(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((Number_of_pairs)));
  return true;
}
bool MC_TA_REF::get_IsAbsolute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((IsAbsolute)));
  return true;
}
bool MC_TA_REF::get_MC_TA_ARRAY(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  const char* index_ = tk_str_skip_array_prefix(name_);
  if (index_ != NULL) {
    if (!MC_TA_ARRAY.hasElement(index_)) { return false; }
    return MC_TA_ARRAY.get(index_).get_(tk_str_skip_object_prefix(name_), v_, obj);
  } else {
    wbuffer_t wb_;
    ubjson_writer_t ub_;
    wbuffer_init_extendable(&wb_);
    ubjson_writer_init(&ub_, (ubjson_write_callback_t)wbuffer_write_binary, &wb_);
    ubjson_writer_write_kv_array_begin(&ub_, "value_");
    for(int i0_ = 1; i0_ <= 100; i0_++) {
        ubjson_writer_write_object_begin(&ub_);
        MC_TA_ARRAY[i0_].save_(&ub_, IEC_SAVE_ALL, nullptr);
        ubjson_writer_write_object_end(&ub_);
    }
    ubjson_writer_write_array_end(&ub_);
    value_set_ubjson(v_, wb_.data, wb_.cursor);
    v_->free_handle = TRUE;
  }
  return true;
}
bool MC_TA_REF::set_Number_of_pairs(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Number_of_pairs) = value_int16(v_);
  return true;
}
bool MC_TA_REF::set_IsAbsolute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (IsAbsolute) = value_bool(v_);
  return true;
}
bool MC_TA_REF::set_MC_TA_ARRAY(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  const char* index_ = tk_str_skip_array_prefix(name_);
  if (index_ != NULL) {
    if (!MC_TA_ARRAY.hasElement(index_)) { return false; }
    return MC_TA_ARRAY.get(index_).set_(tk_str_skip_object_prefix(name_), v_, obj);
  }
  return false;
}

IEC_Property<MC_TA_REF> MC_TA_REF::property_list[] = { 
  {"IsAbsolute", 10, "BOOL", &MC_TA_REF::get_IsAbsolute, &MC_TA_REF::set_IsAbsolute }, 
  {"MC_TA_ARRAY", 11, "ARRAY [1..100] OF ZMC_TA", &MC_TA_REF::get_MC_TA_ARRAY, &MC_TA_REF::set_MC_TA_ARRAY }, 
  {"Number_of_pairs", 15, "INT", &MC_TA_REF::get_Number_of_pairs, &MC_TA_REF::set_Number_of_pairs }, 
};
IEC_Property_Range MC_TA_REF::property_range_list[] = { 
  {0, 1, 10 }, 
  {1, 1, 11 }, 
  {2, 1, 15 }, 
};

bool MC_TA_REF::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((TRUE)) {
    st_ubjson_write_kv_int16(writer_, "Number_of_pairs", ((Number_of_pairs)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_bool(writer_, "IsAbsolute", ((IsAbsolute)));
  }
  if(TRUE) {
    ubjson_writer_write_kv_array_begin(writer_, "MC_TA_ARRAY");
    for(int i0_ = 1; i0_ <= 100; i0_++) {
        ubjson_writer_write_object_begin(writer_);
        MC_TA_ARRAY[i0_].save_(writer_, type_, nullptr);
        ubjson_writer_write_object_end(writer_);
    }
    ubjson_writer_write_array_end(writer_);
  }
  return true;
}

bool MC_TA_REF::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "Number_of_pairs", &v_) == RET_OK)
        (Number_of_pairs) = value_int16(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "IsAbsolute", &v_) == RET_OK)
        (IsAbsolute) = value_bool(&v_);
  }
  if(TRUE) {
    conf_node_t* sub = conf_node_find_child(parent_, "MC_TA_ARRAY");
    for(int i0_ = 1; i0_ <= 100 && sub != nullptr; i0_++) {
        conf_node_t* iter = conf_node_find_child_by_index(sub, i0_-1);
        if (iter != nullptr) MC_TA_ARRAY[i0_].load_(iter, type_, nullptr);
    }
  }
  return true;
}

bool MC_TA_REF::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_TA_REF::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool ZMC_TP::get_delta_time(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((delta_time)));
  return true;
}
bool ZMC_TP::get_position(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((position)));
  return true;
}
bool ZMC_TP::set_delta_time(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (delta_time) = value_uint64(v_);
  return true;
}
bool ZMC_TP::set_position(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (position) = value_double(v_);
  return true;
}

IEC_Property<ZMC_TP> ZMC_TP::property_list[] = { 
  {"position", 8, "LREAL", &ZMC_TP::get_position, &ZMC_TP::set_position }, 
  {"delta_time", 10, "TIME", &ZMC_TP::get_delta_time, &ZMC_TP::set_delta_time }, 
};
IEC_Property_Range ZMC_TP::property_range_list[] = { 
  {0, 1, 8 }, 
  {1, 1, 10 }, 
};

bool ZMC_TP::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((TRUE)) {
    st_ubjson_write_kv_uint64(writer_, "delta_time", ((delta_time)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_double(writer_, "position", ((position)));
  }
  return true;
}

bool ZMC_TP::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "delta_time", &v_) == RET_OK)
        (delta_time) = value_uint64(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "position", &v_) == RET_OK)
        (position) = value_double(&v_);
  }
  return true;
}

bool ZMC_TP::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool ZMC_TP::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_TP_REF::get_Number_of_pairs(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((Number_of_pairs)));
  return true;
}
bool MC_TP_REF::get_IsAbsolute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((IsAbsolute)));
  return true;
}
bool MC_TP_REF::get_MV_TP_ARRAY(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  const char* index_ = tk_str_skip_array_prefix(name_);
  if (index_ != NULL) {
    if (!MV_TP_ARRAY.hasElement(index_)) { return false; }
    return MV_TP_ARRAY.get(index_).get_(tk_str_skip_object_prefix(name_), v_, obj);
  } else {
    wbuffer_t wb_;
    ubjson_writer_t ub_;
    wbuffer_init_extendable(&wb_);
    ubjson_writer_init(&ub_, (ubjson_write_callback_t)wbuffer_write_binary, &wb_);
    ubjson_writer_write_kv_array_begin(&ub_, "value_");
    for(int i0_ = 1; i0_ <= 100; i0_++) {
        ubjson_writer_write_object_begin(&ub_);
        MV_TP_ARRAY[i0_].save_(&ub_, IEC_SAVE_ALL, nullptr);
        ubjson_writer_write_object_end(&ub_);
    }
    ubjson_writer_write_array_end(&ub_);
    value_set_ubjson(v_, wb_.data, wb_.cursor);
    v_->free_handle = TRUE;
  }
  return true;
}
bool MC_TP_REF::set_Number_of_pairs(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Number_of_pairs) = value_int16(v_);
  return true;
}
bool MC_TP_REF::set_IsAbsolute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (IsAbsolute) = value_bool(v_);
  return true;
}
bool MC_TP_REF::set_MV_TP_ARRAY(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  const char* index_ = tk_str_skip_array_prefix(name_);
  if (index_ != NULL) {
    if (!MV_TP_ARRAY.hasElement(index_)) { return false; }
    return MV_TP_ARRAY.get(index_).set_(tk_str_skip_object_prefix(name_), v_, obj);
  }
  return false;
}

IEC_Property<MC_TP_REF> MC_TP_REF::property_list[] = { 
  {"IsAbsolute", 10, "BOOL", &MC_TP_REF::get_IsAbsolute, &MC_TP_REF::set_IsAbsolute }, 
  {"MV_TP_ARRAY", 11, "ARRAY [1..100] OF ZMC_TP", &MC_TP_REF::get_MV_TP_ARRAY, &MC_TP_REF::set_MV_TP_ARRAY }, 
  {"Number_of_pairs", 15, "INT", &MC_TP_REF::get_Number_of_pairs, &MC_TP_REF::set_Number_of_pairs }, 
};
IEC_Property_Range MC_TP_REF::property_range_list[] = { 
  {0, 1, 10 }, 
  {1, 1, 11 }, 
  {2, 1, 15 }, 
};

bool MC_TP_REF::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((TRUE)) {
    st_ubjson_write_kv_int16(writer_, "Number_of_pairs", ((Number_of_pairs)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_bool(writer_, "IsAbsolute", ((IsAbsolute)));
  }
  if(TRUE) {
    ubjson_writer_write_kv_array_begin(writer_, "MV_TP_ARRAY");
    for(int i0_ = 1; i0_ <= 100; i0_++) {
        ubjson_writer_write_object_begin(writer_);
        MV_TP_ARRAY[i0_].save_(writer_, type_, nullptr);
        ubjson_writer_write_object_end(writer_);
    }
    ubjson_writer_write_array_end(writer_);
  }
  return true;
}

bool MC_TP_REF::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "Number_of_pairs", &v_) == RET_OK)
        (Number_of_pairs) = value_int16(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "IsAbsolute", &v_) == RET_OK)
        (IsAbsolute) = value_bool(&v_);
  }
  if(TRUE) {
    conf_node_t* sub = conf_node_find_child(parent_, "MV_TP_ARRAY");
    for(int i0_ = 1; i0_ <= 100 && sub != nullptr; i0_++) {
        conf_node_t* iter = conf_node_find_child_by_index(sub, i0_-1);
        if (iter != nullptr) MV_TP_ARRAY[i0_].load_(iter, type_, nullptr);
    }
  }
  return true;
}

bool MC_TP_REF::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_TP_REF::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_TRACK_TR::get_OnCompensation(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((OnCompensation)));
  return true;
}
bool MC_TRACK_TR::get_OffCompensation(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((OffCompensation)));
  return true;
}
bool MC_TRACK_TR::get_Hysteresis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Hysteresis)));
  return true;
}
bool MC_TRACK_TR::set_OnCompensation(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (OnCompensation) = value_double(v_);
  return true;
}
bool MC_TRACK_TR::set_OffCompensation(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (OffCompensation) = value_double(v_);
  return true;
}
bool MC_TRACK_TR::set_Hysteresis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Hysteresis) = value_double(v_);
  return true;
}

IEC_Property<MC_TRACK_TR> MC_TRACK_TR::property_list[] = { 
  {"Hysteresis", 10, "LREAL", &MC_TRACK_TR::get_Hysteresis, &MC_TRACK_TR::set_Hysteresis }, 
  {"OnCompensation", 14, "LREAL", &MC_TRACK_TR::get_OnCompensation, &MC_TRACK_TR::set_OnCompensation }, 
  {"OffCompensation", 15, "LREAL", &MC_TRACK_TR::get_OffCompensation, &MC_TRACK_TR::set_OffCompensation }, 
};
IEC_Property_Range MC_TRACK_TR::property_range_list[] = { 
  {0, 1, 10 }, 
  {1, 1, 14 }, 
  {2, 1, 15 }, 
};

bool MC_TRACK_TR::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((TRUE)) {
    st_ubjson_write_kv_double(writer_, "OnCompensation", ((OnCompensation)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_double(writer_, "OffCompensation", ((OffCompensation)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_double(writer_, "Hysteresis", ((Hysteresis)));
  }
  return true;
}

bool MC_TRACK_TR::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "OnCompensation", &v_) == RET_OK)
        (OnCompensation) = value_double(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "OffCompensation", &v_) == RET_OK)
        (OffCompensation) = value_double(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "Hysteresis", &v_) == RET_OK)
        (Hysteresis) = value_double(&v_);
  }
  return true;
}

bool MC_TRACK_TR::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_TRACK_TR::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool ZMC_TV::get_delta_time(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((delta_time)));
  return true;
}
bool ZMC_TV::get_velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((velocity)));
  return true;
}
bool ZMC_TV::set_delta_time(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (delta_time) = value_uint64(v_);
  return true;
}
bool ZMC_TV::set_velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (velocity) = value_double(v_);
  return true;
}

IEC_Property<ZMC_TV> ZMC_TV::property_list[] = { 
  {"velocity", 8, "LREAL", &ZMC_TV::get_velocity, &ZMC_TV::set_velocity }, 
  {"delta_time", 10, "TIME", &ZMC_TV::get_delta_time, &ZMC_TV::set_delta_time }, 
};
IEC_Property_Range ZMC_TV::property_range_list[] = { 
  {0, 1, 8 }, 
  {1, 1, 10 }, 
};

bool ZMC_TV::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((TRUE)) {
    st_ubjson_write_kv_uint64(writer_, "delta_time", ((delta_time)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_double(writer_, "velocity", ((velocity)));
  }
  return true;
}

bool ZMC_TV::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "delta_time", &v_) == RET_OK)
        (delta_time) = value_uint64(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "velocity", &v_) == RET_OK)
        (velocity) = value_double(&v_);
  }
  return true;
}

bool ZMC_TV::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool ZMC_TV::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_TV_REF::get_Number_of_pairs(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((Number_of_pairs)));
  return true;
}
bool MC_TV_REF::get_IsAbsolute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((IsAbsolute)));
  return true;
}
bool MC_TV_REF::get_MC_TV_ARRAY(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  const char* index_ = tk_str_skip_array_prefix(name_);
  if (index_ != NULL) {
    if (!MC_TV_ARRAY.hasElement(index_)) { return false; }
    return MC_TV_ARRAY.get(index_).get_(tk_str_skip_object_prefix(name_), v_, obj);
  } else {
    wbuffer_t wb_;
    ubjson_writer_t ub_;
    wbuffer_init_extendable(&wb_);
    ubjson_writer_init(&ub_, (ubjson_write_callback_t)wbuffer_write_binary, &wb_);
    ubjson_writer_write_kv_array_begin(&ub_, "value_");
    for(int i0_ = 1; i0_ <= 100; i0_++) {
        ubjson_writer_write_object_begin(&ub_);
        MC_TV_ARRAY[i0_].save_(&ub_, IEC_SAVE_ALL, nullptr);
        ubjson_writer_write_object_end(&ub_);
    }
    ubjson_writer_write_array_end(&ub_);
    value_set_ubjson(v_, wb_.data, wb_.cursor);
    v_->free_handle = TRUE;
  }
  return true;
}
bool MC_TV_REF::set_Number_of_pairs(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Number_of_pairs) = value_int16(v_);
  return true;
}
bool MC_TV_REF::set_IsAbsolute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (IsAbsolute) = value_bool(v_);
  return true;
}
bool MC_TV_REF::set_MC_TV_ARRAY(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  const char* index_ = tk_str_skip_array_prefix(name_);
  if (index_ != NULL) {
    if (!MC_TV_ARRAY.hasElement(index_)) { return false; }
    return MC_TV_ARRAY.get(index_).set_(tk_str_skip_object_prefix(name_), v_, obj);
  }
  return false;
}

IEC_Property<MC_TV_REF> MC_TV_REF::property_list[] = { 
  {"IsAbsolute", 10, "BOOL", &MC_TV_REF::get_IsAbsolute, &MC_TV_REF::set_IsAbsolute }, 
  {"MC_TV_ARRAY", 11, "ARRAY [1..100] OF ZMC_TV", &MC_TV_REF::get_MC_TV_ARRAY, &MC_TV_REF::set_MC_TV_ARRAY }, 
  {"Number_of_pairs", 15, "INT", &MC_TV_REF::get_Number_of_pairs, &MC_TV_REF::set_Number_of_pairs }, 
};
IEC_Property_Range MC_TV_REF::property_range_list[] = { 
  {0, 1, 10 }, 
  {1, 1, 11 }, 
  {2, 1, 15 }, 
};

bool MC_TV_REF::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((TRUE)) {
    st_ubjson_write_kv_int16(writer_, "Number_of_pairs", ((Number_of_pairs)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_bool(writer_, "IsAbsolute", ((IsAbsolute)));
  }
  if(TRUE) {
    ubjson_writer_write_kv_array_begin(writer_, "MC_TV_ARRAY");
    for(int i0_ = 1; i0_ <= 100; i0_++) {
        ubjson_writer_write_object_begin(writer_);
        MC_TV_ARRAY[i0_].save_(writer_, type_, nullptr);
        ubjson_writer_write_object_end(writer_);
    }
    ubjson_writer_write_array_end(writer_);
  }
  return true;
}

bool MC_TV_REF::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "Number_of_pairs", &v_) == RET_OK)
        (Number_of_pairs) = value_int16(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "IsAbsolute", &v_) == RET_OK)
        (IsAbsolute) = value_bool(&v_);
  }
  if(TRUE) {
    conf_node_t* sub = conf_node_find_child(parent_, "MC_TV_ARRAY");
    for(int i0_ = 1; i0_ <= 100 && sub != nullptr; i0_++) {
        conf_node_t* iter = conf_node_find_child_by_index(sub, i0_-1);
        if (iter != nullptr) MC_TV_ARRAY[i0_].load_(iter, type_, nullptr);
    }
  }
  return true;
}

bool MC_TV_REF::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_TV_REF::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool TRIGGER_REF::get_iTriggerNumber(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((iTriggerNumber)));
  return true;
}
bool TRIGGER_REF::get_bFastLatching(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bFastLatching)));
  return true;
}
bool TRIGGER_REF::get_bInput(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bInput)));
  return true;
}
bool TRIGGER_REF::set_iTriggerNumber(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (iTriggerNumber) = value_int16(v_);
  return true;
}
bool TRIGGER_REF::set_bFastLatching(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bFastLatching) = value_bool(v_);
  return true;
}
bool TRIGGER_REF::set_bInput(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bInput) = value_bool(v_);
  return true;
}

IEC_Property<TRIGGER_REF> TRIGGER_REF::property_list[] = { 
  {"bInput", 6, "BOOL", &TRIGGER_REF::get_bInput, &TRIGGER_REF::set_bInput }, 
  {"bFastLatching", 13, "BOOL", &TRIGGER_REF::get_bFastLatching, &TRIGGER_REF::set_bFastLatching }, 
  {"iTriggerNumber", 14, "INT", &TRIGGER_REF::get_iTriggerNumber, &TRIGGER_REF::set_iTriggerNumber }, 
};
IEC_Property_Range TRIGGER_REF::property_range_list[] = { 
  {0, 1, 6 }, 
  {1, 1, 13 }, 
  {2, 1, 14 }, 
};

bool TRIGGER_REF::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((TRUE)) {
    st_ubjson_write_kv_int16(writer_, "iTriggerNumber", ((iTriggerNumber)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_bool(writer_, "bFastLatching", ((bFastLatching)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_bool(writer_, "bInput", ((bInput)));
  }
  return true;
}

bool TRIGGER_REF::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "iTriggerNumber", &v_) == RET_OK)
        (iTriggerNumber) = value_int16(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "bFastLatching", &v_) == RET_OK)
        (bFastLatching) = value_bool(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "bInput", &v_) == RET_OK)
        (bInput) = value_bool(&v_);
  }
  return true;
}

bool TRIGGER_REF::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool TRIGGER_REF::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool ZMC_TappetData::get_pTaps(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  const char* index_ = tk_str_skip_array_prefix(name_);
  if (index_ != NULL) {
    if (!pTaps.hasElement(index_)) { return false; }
    const char* p_ = strchr(name_, ']');
    if (*(p_ + 1) == 0) {
      value_set_pointer(v_, pTaps.get(index_));
      return true;
    }

    return pTaps.get(index_)->get_(tk_str_skip_object_prefix(name_), v_, obj);
  } else {
    wbuffer_t wb_;
    ubjson_writer_t ub_;
    wbuffer_init_extendable(&wb_);
    ubjson_writer_init(&ub_, (ubjson_write_callback_t)wbuffer_write_binary, &wb_);
    ubjson_writer_write_kv_array_begin(&ub_, "value_");
    for(int i0_ = 0; i0_ <= 2; i0_++) {
      if (pTaps[i0_] == NULL) continue;
        st_ubjson_write_pointer(&ub_, (pTaps[i0_]));
    }
    ubjson_writer_write_array_end(&ub_);
    value_set_ubjson(v_, wb_.data, wb_.cursor);
    v_->free_handle = TRUE;
  }
  return true;
}
bool ZMC_TappetData::get_dwCycleTime(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint32(v_, ((dwCycleTime)));
  return true;
}
bool ZMC_TappetData::get_byChannels(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint8(v_, ((byChannels)));
  return true;
}
bool ZMC_TappetData::get_bRestart(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bRestart)));
  return true;
}
bool ZMC_TappetData::set_pTaps(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  const char* index_ = tk_str_skip_array_prefix(name_);
  if (index_ != NULL) {
    if (!pTaps.hasElement(index_)) { return false; }

    const char* p_ = strchr(name_, ']');
    if (*(p_ + 1) == 0) {
      return pTaps.get(index_)->set_(NULL, v_, obj);
    } else if (*(p_ + 1) != '^') { return false; }

    return pTaps.get(index_)->set_(tk_str_skip_object_prefix(name_), v_, obj);
  }
  return false;
}
bool ZMC_TappetData::set_dwCycleTime(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (dwCycleTime) = value_uint32(v_);
  return true;
}
bool ZMC_TappetData::set_byChannels(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (byChannels) = value_uint8(v_);
  return true;
}
bool ZMC_TappetData::set_bRestart(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bRestart) = value_bool(v_);
  return true;
}

IEC_Property<ZMC_TappetData> ZMC_TappetData::property_list[] = { 
  {"pTaps", 5, "ARRAY [0..2] OF POINTER TO ZMC_CAMTappet", &ZMC_TappetData::get_pTaps, &ZMC_TappetData::set_pTaps }, 
  {"bRestart", 8, "BOOL", &ZMC_TappetData::get_bRestart, &ZMC_TappetData::set_bRestart }, 
  {"byChannels", 10, "BYTE", &ZMC_TappetData::get_byChannels, &ZMC_TappetData::set_byChannels }, 
  {"dwCycleTime", 11, "DWORD", &ZMC_TappetData::get_dwCycleTime, &ZMC_TappetData::set_dwCycleTime }, 
};
IEC_Property_Range ZMC_TappetData::property_range_list[] = { 
  {0, 1, 5 }, 
  {1, 1, 8 }, 
  {2, 1, 10 }, 
  {3, 1, 11 }, 
};

bool ZMC_TappetData::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if(TRUE) {
    ubjson_writer_write_kv_array_begin(writer_, "pTaps");
    for(int i0_ = 0; i0_ <= 2; i0_++) {
      if (pTaps[i0_] == NULL) continue;
        ubjson_writer_write_object_begin(writer_);
        pTaps[i0_]->save_(writer_, type_, nullptr);
        ubjson_writer_write_object_end(writer_);
    }
    ubjson_writer_write_array_end(writer_);
  }
  if((TRUE)) {
    st_ubjson_write_kv_uint32(writer_, "dwCycleTime", ((dwCycleTime)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_uint8(writer_, "byChannels", ((byChannels)));
  }
  if((TRUE)) {
    st_ubjson_write_kv_bool(writer_, "bRestart", ((bRestart)));
  }
  return true;
}

bool ZMC_TappetData::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if(TRUE) {
    conf_node_t* sub = conf_node_find_child(parent_, "pTaps");
    for(int i0_ = 0; i0_ <= 2 && sub != nullptr; i0_++) {
      if (pTaps[i0_] == NULL) continue;
        conf_node_t* iter = conf_node_find_child_by_index(sub, i0_-0);
        if (iter != nullptr) pTaps[i0_]->load_(iter, type_, nullptr);
    }
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "dwCycleTime", &v_) == RET_OK)
        (dwCycleTime) = value_uint32(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "byChannels", &v_) == RET_OK)
        (byChannels) = value_uint8(&v_);
  }
  if((TRUE)) {
      if(conf_node_get_child_value(parent_, "bRestart", &v_) == RET_OK)
        (bRestart) = value_bool(&v_);
  }
  return true;
}

bool ZMC_TappetData::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool ZMC_TappetData::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool DEV_VAR_global_var_list_type_def::get_CiA402_AXIS_0(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, CiA402_AXIS_0);
    return true;
  } else if (*name_ != '^' || CiA402_AXIS_0 == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return CiA402_AXIS_0->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool DEV_VAR_global_var_list_type_def::set_CiA402_AXIS_0(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    CiA402_AXIS_0 = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || CiA402_AXIS_0 == NULL) { return false; }

  return CiA402_AXIS_0->set_(tk_str_skip_object_prefix(name_), v_, obj);
}

IEC_Property<DEV_VAR_global_var_list_type_def> DEV_VAR_global_var_list_type_def::property_list[] = { 
  {"CiA402_AXIS_0", 13, "POINTER TO AXIS_BASE", &DEV_VAR_global_var_list_type_def::get_CiA402_AXIS_0, &DEV_VAR_global_var_list_type_def::set_CiA402_AXIS_0 }, 
};
IEC_Property_Range DEV_VAR_global_var_list_type_def::property_range_list[] = { 
  {0, 1, 13 }, 
};

bool DEV_VAR_global_var_list_type_def::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (CiA402_AXIS_0 != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "CiA402_AXIS_0");
      CiA402_AXIS_0->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  return true;
}

bool DEV_VAR_global_var_list_type_def::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (CiA402_AXIS_0 != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "CiA402_AXIS_0");
      if (sub != nullptr) CiA402_AXIS_0->load_(sub, type_, nullptr);
  }
  return true;
}

bool DEV_VAR_global_var_list_type_def::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool DEV_VAR_global_var_list_type_def::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool ECAT_MASTER_KPA_IO::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool ECAT_MASTER_KPA_IO::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}

IEC_Property<ECAT_MASTER_KPA_IO> ECAT_MASTER_KPA_IO::property_list[] = { 
  {"native", 6, "ULINT", &ECAT_MASTER_KPA_IO::get_native, &ECAT_MASTER_KPA_IO::set_native }, 
};
IEC_Property_Range ECAT_MASTER_KPA_IO::property_range_list[] = { 
  {0, 1, 6 }, 
};

bool ECAT_MASTER_KPA_IO::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  return true;
}

bool ECAT_MASTER_KPA_IO::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  return true;
}

bool ECAT_MASTER_KPA_IO::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool ECAT_MASTER_KPA_IO::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool ETC_CO_SdoRead::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool ETC_CO_SdoRead::get_xExecute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((xExecute)));
  return true;
}
bool ETC_CO_SdoRead::get_xAbort(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((xAbort)));
  return true;
}
bool ETC_CO_SdoRead::get_usiCom(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint8(v_, ((usiCom)));
  return true;
}
bool ETC_CO_SdoRead::get_uiDevice(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((uiDevice)));
  return true;
}
bool ETC_CO_SdoRead::get_usiChannel(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint8(v_, ((usiChannel)));
  return true;
}
bool ETC_CO_SdoRead::get_wIndex(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((wIndex)));
  return true;
}
bool ETC_CO_SdoRead::get_bySubindex(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint8(v_, ((bySubindex)));
  return true;
}
bool ETC_CO_SdoRead::get_udiTimeOut(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint32(v_, ((udiTimeOut)));
  return true;
}
bool ETC_CO_SdoRead::get_pBuffer(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, pBuffer);
    return true;
  } else if (*name_ != '^' || pBuffer == NULL) { return false; }
  return true;
}
bool ETC_CO_SdoRead::get_szSize(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint32(v_, ((szSize)));
  return true;
}
bool ETC_CO_SdoRead::get_xDone(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((xDone)));
  return true;
}
bool ETC_CO_SdoRead::get_xBusy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((xBusy)));
  return true;
}
bool ETC_CO_SdoRead::get_xError(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((xError)));
  return true;
}
bool ETC_CO_SdoRead::get_eError(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int32(v_, ((eError)));
  return true;
}
bool ETC_CO_SdoRead::get_udiSdoAbort(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint32(v_, ((udiSdoAbort)));
  return true;
}
bool ETC_CO_SdoRead::get_szDataRead(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint32(v_, ((szDataRead)));
  return true;
}
bool ETC_CO_SdoRead::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool ETC_CO_SdoRead::set_xExecute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (xExecute) = value_bool(v_);
  return true;
}
bool ETC_CO_SdoRead::set_xAbort(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (xAbort) = value_bool(v_);
  return true;
}
bool ETC_CO_SdoRead::set_usiCom(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (usiCom) = value_uint8(v_);
  return true;
}
bool ETC_CO_SdoRead::set_uiDevice(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (uiDevice) = value_uint16(v_);
  return true;
}
bool ETC_CO_SdoRead::set_usiChannel(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (usiChannel) = value_uint8(v_);
  return true;
}
bool ETC_CO_SdoRead::set_wIndex(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (wIndex) = value_uint16(v_);
  return true;
}
bool ETC_CO_SdoRead::set_bySubindex(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bySubindex) = value_uint8(v_);
  return true;
}
bool ETC_CO_SdoRead::set_udiTimeOut(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (udiTimeOut) = value_uint32(v_);
  return true;
}
bool ETC_CO_SdoRead::set_pBuffer(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    pBuffer = static_cast<VOID_ADR >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || pBuffer == NULL) { return false; }

  return true;
}
bool ETC_CO_SdoRead::set_szSize(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (szSize) = value_uint32(v_);
  return true;
}
bool ETC_CO_SdoRead::set_xDone(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (xDone) = value_bool(v_);
  return true;
}
bool ETC_CO_SdoRead::set_xBusy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (xBusy) = value_bool(v_);
  return true;
}
bool ETC_CO_SdoRead::set_xError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (xError) = value_bool(v_);
  return true;
}
bool ETC_CO_SdoRead::set_eError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (eError) = value_int32(v_);
  return true;
}
bool ETC_CO_SdoRead::set_udiSdoAbort(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (udiSdoAbort) = value_uint32(v_);
  return true;
}
bool ETC_CO_SdoRead::set_szDataRead(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (szDataRead) = value_uint32(v_);
  return true;
}

IEC_Property<ETC_CO_SdoRead> ETC_CO_SdoRead::property_list[] = { 
  {"xBusy", 5, "BOOL", &ETC_CO_SdoRead::get_xBusy, &ETC_CO_SdoRead::set_xBusy }, 
  {"xDone", 5, "BOOL", &ETC_CO_SdoRead::get_xDone, &ETC_CO_SdoRead::set_xDone }, 
  {"eError", 6, "DINT", &ETC_CO_SdoRead::get_eError, &ETC_CO_SdoRead::set_eError }, 
  {"native", 6, "ULINT", &ETC_CO_SdoRead::get_native, &ETC_CO_SdoRead::set_native }, 
  {"szSize", 6, "UDINT", &ETC_CO_SdoRead::get_szSize, &ETC_CO_SdoRead::set_szSize }, 
  {"usiCom", 6, "USINT", &ETC_CO_SdoRead::get_usiCom, &ETC_CO_SdoRead::set_usiCom }, 
  {"wIndex", 6, "WORD", &ETC_CO_SdoRead::get_wIndex, &ETC_CO_SdoRead::set_wIndex }, 
  {"xAbort", 6, "BOOL", &ETC_CO_SdoRead::get_xAbort, &ETC_CO_SdoRead::set_xAbort }, 
  {"xError", 6, "BOOL", &ETC_CO_SdoRead::get_xError, &ETC_CO_SdoRead::set_xError }, 
  {"pBuffer", 7, "POINTER TO VOID_ADR", &ETC_CO_SdoRead::get_pBuffer, &ETC_CO_SdoRead::set_pBuffer }, 
  {"uiDevice", 8, "UINT", &ETC_CO_SdoRead::get_uiDevice, &ETC_CO_SdoRead::set_uiDevice }, 
  {"xExecute", 8, "BOOL", &ETC_CO_SdoRead::get_xExecute, &ETC_CO_SdoRead::set_xExecute }, 
  {"bySubindex", 10, "BYTE", &ETC_CO_SdoRead::get_bySubindex, &ETC_CO_SdoRead::set_bySubindex }, 
  {"szDataRead", 10, "UDINT", &ETC_CO_SdoRead::get_szDataRead, &ETC_CO_SdoRead::set_szDataRead }, 
  {"udiTimeOut", 10, "UDINT", &ETC_CO_SdoRead::get_udiTimeOut, &ETC_CO_SdoRead::set_udiTimeOut }, 
  {"usiChannel", 10, "USINT", &ETC_CO_SdoRead::get_usiChannel, &ETC_CO_SdoRead::set_usiChannel }, 
  {"udiSdoAbort", 11, "UDINT", &ETC_CO_SdoRead::get_udiSdoAbort, &ETC_CO_SdoRead::set_udiSdoAbort }, 
};
IEC_Property_Range ETC_CO_SdoRead::property_range_list[] = { 
  {0, 2, 5 }, 
  {2, 7, 6 }, 
  {9, 1, 7 }, 
  {10, 2, 8 }, 
  {12, 4, 10 }, 
  {16, 1, 11 }, 
};

bool ETC_CO_SdoRead::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "xExecute", ((xExecute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "xAbort", ((xAbort)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint8(writer_, "usiCom", ((usiCom)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "uiDevice", ((uiDevice)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint8(writer_, "usiChannel", ((usiChannel)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "wIndex", ((wIndex)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint8(writer_, "bySubindex", ((bySubindex)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint32(writer_, "udiTimeOut", ((udiTimeOut)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (pBuffer != NULL)) {
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint32(writer_, "szSize", ((szSize)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "xDone", ((xDone)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "xBusy", ((xBusy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "xError", ((xError)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int32(writer_, "eError", ((eError)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint32(writer_, "udiSdoAbort", ((udiSdoAbort)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint32(writer_, "szDataRead", ((szDataRead)));
  }
  return true;
}

bool ETC_CO_SdoRead::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "xExecute", &v_) == RET_OK)
        (xExecute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "xAbort", &v_) == RET_OK)
        (xAbort) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "usiCom", &v_) == RET_OK)
        (usiCom) = value_uint8(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "uiDevice", &v_) == RET_OK)
        (uiDevice) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "usiChannel", &v_) == RET_OK)
        (usiChannel) = value_uint8(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "wIndex", &v_) == RET_OK)
        (wIndex) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bySubindex", &v_) == RET_OK)
        (bySubindex) = value_uint8(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "udiTimeOut", &v_) == RET_OK)
        (udiTimeOut) = value_uint32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (pBuffer != NULL)) {
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "szSize", &v_) == RET_OK)
        (szSize) = value_uint32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "xDone", &v_) == RET_OK)
        (xDone) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "xBusy", &v_) == RET_OK)
        (xBusy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "xError", &v_) == RET_OK)
        (xError) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "eError", &v_) == RET_OK)
        (eError) = value_int32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "udiSdoAbort", &v_) == RET_OK)
        (udiSdoAbort) = value_uint32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "szDataRead", &v_) == RET_OK)
        (szDataRead) = value_uint32(&v_);
  }
  return true;
}

bool ETC_CO_SdoRead::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool ETC_CO_SdoRead::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool ETC_CO_SdoWrite::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool ETC_CO_SdoWrite::get_xExecute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((xExecute)));
  return true;
}
bool ETC_CO_SdoWrite::get_xAbort(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((xAbort)));
  return true;
}
bool ETC_CO_SdoWrite::get_usiCom(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint8(v_, ((usiCom)));
  return true;
}
bool ETC_CO_SdoWrite::get_uiDevice(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((uiDevice)));
  return true;
}
bool ETC_CO_SdoWrite::get_usiChannel(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint8(v_, ((usiChannel)));
  return true;
}
bool ETC_CO_SdoWrite::get_wIndex(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((wIndex)));
  return true;
}
bool ETC_CO_SdoWrite::get_bySubindex(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint8(v_, ((bySubindex)));
  return true;
}
bool ETC_CO_SdoWrite::get_udiTimeOut(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint32(v_, ((udiTimeOut)));
  return true;
}
bool ETC_CO_SdoWrite::get_pBuffer(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, pBuffer);
    return true;
  } else if (*name_ != '^' || pBuffer == NULL) { return false; }
  return true;
}
bool ETC_CO_SdoWrite::get_szSize(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint32(v_, ((szSize)));
  return true;
}
bool ETC_CO_SdoWrite::get_xDone(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((xDone)));
  return true;
}
bool ETC_CO_SdoWrite::get_xBusy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((xBusy)));
  return true;
}
bool ETC_CO_SdoWrite::get_xError(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((xError)));
  return true;
}
bool ETC_CO_SdoWrite::get_eError(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int32(v_, ((eError)));
  return true;
}
bool ETC_CO_SdoWrite::get_udiSdoAbort(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint32(v_, ((udiSdoAbort)));
  return true;
}
bool ETC_CO_SdoWrite::get_szDataWritten(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint32(v_, ((szDataWritten)));
  return true;
}
bool ETC_CO_SdoWrite::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool ETC_CO_SdoWrite::set_xExecute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (xExecute) = value_bool(v_);
  return true;
}
bool ETC_CO_SdoWrite::set_xAbort(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (xAbort) = value_bool(v_);
  return true;
}
bool ETC_CO_SdoWrite::set_usiCom(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (usiCom) = value_uint8(v_);
  return true;
}
bool ETC_CO_SdoWrite::set_uiDevice(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (uiDevice) = value_uint16(v_);
  return true;
}
bool ETC_CO_SdoWrite::set_usiChannel(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (usiChannel) = value_uint8(v_);
  return true;
}
bool ETC_CO_SdoWrite::set_wIndex(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (wIndex) = value_uint16(v_);
  return true;
}
bool ETC_CO_SdoWrite::set_bySubindex(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bySubindex) = value_uint8(v_);
  return true;
}
bool ETC_CO_SdoWrite::set_udiTimeOut(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (udiTimeOut) = value_uint32(v_);
  return true;
}
bool ETC_CO_SdoWrite::set_pBuffer(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    pBuffer = static_cast<VOID_ADR >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || pBuffer == NULL) { return false; }

  return true;
}
bool ETC_CO_SdoWrite::set_szSize(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (szSize) = value_uint32(v_);
  return true;
}
bool ETC_CO_SdoWrite::set_xDone(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (xDone) = value_bool(v_);
  return true;
}
bool ETC_CO_SdoWrite::set_xBusy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (xBusy) = value_bool(v_);
  return true;
}
bool ETC_CO_SdoWrite::set_xError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (xError) = value_bool(v_);
  return true;
}
bool ETC_CO_SdoWrite::set_eError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (eError) = value_int32(v_);
  return true;
}
bool ETC_CO_SdoWrite::set_udiSdoAbort(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (udiSdoAbort) = value_uint32(v_);
  return true;
}
bool ETC_CO_SdoWrite::set_szDataWritten(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (szDataWritten) = value_uint32(v_);
  return true;
}

IEC_Property<ETC_CO_SdoWrite> ETC_CO_SdoWrite::property_list[] = { 
  {"xBusy", 5, "BOOL", &ETC_CO_SdoWrite::get_xBusy, &ETC_CO_SdoWrite::set_xBusy }, 
  {"xDone", 5, "BOOL", &ETC_CO_SdoWrite::get_xDone, &ETC_CO_SdoWrite::set_xDone }, 
  {"eError", 6, "DINT", &ETC_CO_SdoWrite::get_eError, &ETC_CO_SdoWrite::set_eError }, 
  {"native", 6, "ULINT", &ETC_CO_SdoWrite::get_native, &ETC_CO_SdoWrite::set_native }, 
  {"szSize", 6, "UDINT", &ETC_CO_SdoWrite::get_szSize, &ETC_CO_SdoWrite::set_szSize }, 
  {"usiCom", 6, "USINT", &ETC_CO_SdoWrite::get_usiCom, &ETC_CO_SdoWrite::set_usiCom }, 
  {"wIndex", 6, "WORD", &ETC_CO_SdoWrite::get_wIndex, &ETC_CO_SdoWrite::set_wIndex }, 
  {"xAbort", 6, "BOOL", &ETC_CO_SdoWrite::get_xAbort, &ETC_CO_SdoWrite::set_xAbort }, 
  {"xError", 6, "BOOL", &ETC_CO_SdoWrite::get_xError, &ETC_CO_SdoWrite::set_xError }, 
  {"pBuffer", 7, "POINTER TO VOID_ADR", &ETC_CO_SdoWrite::get_pBuffer, &ETC_CO_SdoWrite::set_pBuffer }, 
  {"uiDevice", 8, "UINT", &ETC_CO_SdoWrite::get_uiDevice, &ETC_CO_SdoWrite::set_uiDevice }, 
  {"xExecute", 8, "BOOL", &ETC_CO_SdoWrite::get_xExecute, &ETC_CO_SdoWrite::set_xExecute }, 
  {"bySubindex", 10, "BYTE", &ETC_CO_SdoWrite::get_bySubindex, &ETC_CO_SdoWrite::set_bySubindex }, 
  {"udiTimeOut", 10, "UDINT", &ETC_CO_SdoWrite::get_udiTimeOut, &ETC_CO_SdoWrite::set_udiTimeOut }, 
  {"usiChannel", 10, "USINT", &ETC_CO_SdoWrite::get_usiChannel, &ETC_CO_SdoWrite::set_usiChannel }, 
  {"udiSdoAbort", 11, "UDINT", &ETC_CO_SdoWrite::get_udiSdoAbort, &ETC_CO_SdoWrite::set_udiSdoAbort }, 
  {"szDataWritten", 13, "UDINT", &ETC_CO_SdoWrite::get_szDataWritten, &ETC_CO_SdoWrite::set_szDataWritten }, 
};
IEC_Property_Range ETC_CO_SdoWrite::property_range_list[] = { 
  {0, 2, 5 }, 
  {2, 7, 6 }, 
  {9, 1, 7 }, 
  {10, 2, 8 }, 
  {12, 3, 10 }, 
  {15, 1, 11 }, 
  {16, 1, 13 }, 
};

bool ETC_CO_SdoWrite::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "xExecute", ((xExecute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "xAbort", ((xAbort)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint8(writer_, "usiCom", ((usiCom)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "uiDevice", ((uiDevice)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint8(writer_, "usiChannel", ((usiChannel)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "wIndex", ((wIndex)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint8(writer_, "bySubindex", ((bySubindex)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint32(writer_, "udiTimeOut", ((udiTimeOut)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (pBuffer != NULL)) {
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint32(writer_, "szSize", ((szSize)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "xDone", ((xDone)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "xBusy", ((xBusy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "xError", ((xError)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int32(writer_, "eError", ((eError)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint32(writer_, "udiSdoAbort", ((udiSdoAbort)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint32(writer_, "szDataWritten", ((szDataWritten)));
  }
  return true;
}

bool ETC_CO_SdoWrite::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "xExecute", &v_) == RET_OK)
        (xExecute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "xAbort", &v_) == RET_OK)
        (xAbort) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "usiCom", &v_) == RET_OK)
        (usiCom) = value_uint8(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "uiDevice", &v_) == RET_OK)
        (uiDevice) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "usiChannel", &v_) == RET_OK)
        (usiChannel) = value_uint8(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "wIndex", &v_) == RET_OK)
        (wIndex) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bySubindex", &v_) == RET_OK)
        (bySubindex) = value_uint8(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "udiTimeOut", &v_) == RET_OK)
        (udiTimeOut) = value_uint32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (pBuffer != NULL)) {
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "szSize", &v_) == RET_OK)
        (szSize) = value_uint32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "xDone", &v_) == RET_OK)
        (xDone) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "xBusy", &v_) == RET_OK)
        (xBusy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "xError", &v_) == RET_OK)
        (xError) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "eError", &v_) == RET_OK)
        (eError) = value_int32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "udiSdoAbort", &v_) == RET_OK)
        (udiSdoAbort) = value_uint32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "szDataWritten", &v_) == RET_OK)
        (szDataWritten) = value_uint32(&v_);
  }
  return true;
}

bool ETC_CO_SdoWrite::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool ETC_CO_SdoWrite::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MODBUS_MASTER_IO::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MODBUS_MASTER_IO::get_xDone(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((xDone)));
  return true;
}
bool MODBUS_MASTER_IO::get_xBusy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((xBusy)));
  return true;
}
bool MODBUS_MASTER_IO::get_xError(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((xError)));
  return true;
}
bool MODBUS_MASTER_IO::get_iErrorCode(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((iErrorCode)));
  return true;
}
bool MODBUS_MASTER_IO::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MODBUS_MASTER_IO::set_xDone(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (xDone) = value_bool(v_);
  return true;
}
bool MODBUS_MASTER_IO::set_xBusy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (xBusy) = value_bool(v_);
  return true;
}
bool MODBUS_MASTER_IO::set_xError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (xError) = value_bool(v_);
  return true;
}
bool MODBUS_MASTER_IO::set_iErrorCode(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (iErrorCode) = value_int16(v_);
  return true;
}

IEC_Property<MODBUS_MASTER_IO> MODBUS_MASTER_IO::property_list[] = { 
  {"xBusy", 5, "BOOL", &MODBUS_MASTER_IO::get_xBusy, &MODBUS_MASTER_IO::set_xBusy }, 
  {"xDone", 5, "BOOL", &MODBUS_MASTER_IO::get_xDone, &MODBUS_MASTER_IO::set_xDone }, 
  {"native", 6, "ULINT", &MODBUS_MASTER_IO::get_native, &MODBUS_MASTER_IO::set_native }, 
  {"xError", 6, "BOOL", &MODBUS_MASTER_IO::get_xError, &MODBUS_MASTER_IO::set_xError }, 
  {"iErrorCode", 10, "INT", &MODBUS_MASTER_IO::get_iErrorCode, &MODBUS_MASTER_IO::set_iErrorCode }, 
};
IEC_Property_Range MODBUS_MASTER_IO::property_range_list[] = { 
  {0, 2, 5 }, 
  {2, 2, 6 }, 
  {4, 1, 10 }, 
};

bool MODBUS_MASTER_IO::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "xDone", ((xDone)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "xBusy", ((xBusy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "xError", ((xError)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int16(writer_, "iErrorCode", ((iErrorCode)));
  }
  return true;
}

bool MODBUS_MASTER_IO::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "xDone", &v_) == RET_OK)
        (xDone) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "xBusy", &v_) == RET_OK)
        (xBusy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "xError", &v_) == RET_OK)
        (xError) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "iErrorCode", &v_) == RET_OK)
        (iErrorCode) = value_int16(&v_);
  }
  return true;
}

bool MODBUS_MASTER_IO::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MODBUS_MASTER_IO::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool AXIS_CIA402_IO::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool AXIS_CIA402_IO::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}

IEC_Property<AXIS_CIA402_IO> AXIS_CIA402_IO::property_list[] = { 
  {"native", 6, "ULINT", &AXIS_CIA402_IO::get_native, &AXIS_CIA402_IO::set_native }, 
};
IEC_Property_Range AXIS_CIA402_IO::property_range_list[] = { 
  {0, 1, 6 }, 
};

bool AXIS_CIA402_IO::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  return true;
}

bool AXIS_CIA402_IO::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  return true;
}

bool AXIS_CIA402_IO::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool AXIS_CIA402_IO::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool AXIS_FREE_ENCODER_IO::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool AXIS_FREE_ENCODER_IO::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}

IEC_Property<AXIS_FREE_ENCODER_IO> AXIS_FREE_ENCODER_IO::property_list[] = { 
  {"native", 6, "ULINT", &AXIS_FREE_ENCODER_IO::get_native, &AXIS_FREE_ENCODER_IO::set_native }, 
};
IEC_Property_Range AXIS_FREE_ENCODER_IO::property_range_list[] = { 
  {0, 1, 6 }, 
};

bool AXIS_FREE_ENCODER_IO::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  return true;
}

bool AXIS_FREE_ENCODER_IO::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  return true;
}

bool AXIS_FREE_ENCODER_IO::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool AXIS_FREE_ENCODER_IO::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool AXIS_VIRTUAL_IO::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool AXIS_VIRTUAL_IO::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}

IEC_Property<AXIS_VIRTUAL_IO> AXIS_VIRTUAL_IO::property_list[] = { 
  {"native", 6, "ULINT", &AXIS_VIRTUAL_IO::get_native, &AXIS_VIRTUAL_IO::set_native }, 
};
IEC_Property_Range AXIS_VIRTUAL_IO::property_range_list[] = { 
  {0, 1, 6 }, 
};

bool AXIS_VIRTUAL_IO::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  return true;
}

bool AXIS_VIRTUAL_IO::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  return true;
}

bool AXIS_VIRTUAL_IO::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool AXIS_VIRTUAL_IO::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_AbortTrigger::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_AbortTrigger::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_AbortTrigger::get_TriggerInput(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return TriggerInput.get_(name_, v_, obj);
}
bool MC_AbortTrigger::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_AbortTrigger::get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Done)));
  return true;
}
bool MC_AbortTrigger::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_AbortTrigger::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_AbortTrigger::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_AbortTrigger::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_AbortTrigger::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_AbortTrigger::set_TriggerInput(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return TriggerInput.set_(name_, v_, obj);
}
bool MC_AbortTrigger::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_AbortTrigger::set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Done) = value_bool(v_);
  return true;
}
bool MC_AbortTrigger::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_AbortTrigger::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_AbortTrigger::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_AbortTrigger> MC_AbortTrigger::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_AbortTrigger::get_Axis, &MC_AbortTrigger::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_AbortTrigger::get_Busy, &MC_AbortTrigger::set_Busy }, 
  {"Done", 4, "BOOL", &MC_AbortTrigger::get_Done, &MC_AbortTrigger::set_Done }, 
  {"Error", 5, "BOOL", &MC_AbortTrigger::get_Error, &MC_AbortTrigger::set_Error }, 
  {"native", 6, "ULINT", &MC_AbortTrigger::get_native, &MC_AbortTrigger::set_native }, 
  {"ErrorID", 7, "WORD", &MC_AbortTrigger::get_ErrorID, &MC_AbortTrigger::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_AbortTrigger::get_Execute, &MC_AbortTrigger::set_Execute }, 
  {"TriggerInput", 12, "TRIGGER_REF", &MC_AbortTrigger::get_TriggerInput, &MC_AbortTrigger::set_TriggerInput }, 
};
IEC_Property_Range MC_AbortTrigger::property_range_list[] = { 
  {0, 3, 4 }, 
  {3, 1, 5 }, 
  {4, 1, 6 }, 
  {5, 2, 7 }, 
  {7, 1, 12 }, 
};

bool MC_AbortTrigger::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
      ubjson_writer_write_kv_object_begin(writer_, "TriggerInput");
      TriggerInput.save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Done", ((Done)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_AbortTrigger::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      conf_node_t* sub = conf_node_find_child(parent_, "TriggerInput");
      if (sub != nullptr) TriggerInput.load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Done", &v_) == RET_OK)
        (Done) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_AbortTrigger::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_AbortTrigger::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_AccelerationProfile::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_AccelerationProfile::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_AccelerationProfile::get_TimeAcceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return TimeAcceleration.get_(name_, v_, obj);
}
bool MC_AccelerationProfile::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_AccelerationProfile::get_ArraySize(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((ArraySize)));
  return true;
}
bool MC_AccelerationProfile::get_AccelerationScale(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((AccelerationScale)));
  return true;
}
bool MC_AccelerationProfile::get_Offset(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Offset)));
  return true;
}
bool MC_AccelerationProfile::get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Done)));
  return true;
}
bool MC_AccelerationProfile::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_AccelerationProfile::get_CommandAbort(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((CommandAbort)));
  return true;
}
bool MC_AccelerationProfile::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_AccelerationProfile::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_AccelerationProfile::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_AccelerationProfile::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_AccelerationProfile::set_TimeAcceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return TimeAcceleration.set_(name_, v_, obj);
}
bool MC_AccelerationProfile::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_AccelerationProfile::set_ArraySize(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ArraySize) = value_int16(v_);
  return true;
}
bool MC_AccelerationProfile::set_AccelerationScale(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (AccelerationScale) = value_double(v_);
  return true;
}
bool MC_AccelerationProfile::set_Offset(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Offset) = value_double(v_);
  return true;
}
bool MC_AccelerationProfile::set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Done) = value_bool(v_);
  return true;
}
bool MC_AccelerationProfile::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_AccelerationProfile::set_CommandAbort(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (CommandAbort) = value_bool(v_);
  return true;
}
bool MC_AccelerationProfile::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_AccelerationProfile::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_AccelerationProfile> MC_AccelerationProfile::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_AccelerationProfile::get_Axis, &MC_AccelerationProfile::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_AccelerationProfile::get_Busy, &MC_AccelerationProfile::set_Busy }, 
  {"Done", 4, "BOOL", &MC_AccelerationProfile::get_Done, &MC_AccelerationProfile::set_Done }, 
  {"Error", 5, "BOOL", &MC_AccelerationProfile::get_Error, &MC_AccelerationProfile::set_Error }, 
  {"Offset", 6, "LREAL", &MC_AccelerationProfile::get_Offset, &MC_AccelerationProfile::set_Offset }, 
  {"native", 6, "ULINT", &MC_AccelerationProfile::get_native, &MC_AccelerationProfile::set_native }, 
  {"ErrorID", 7, "WORD", &MC_AccelerationProfile::get_ErrorID, &MC_AccelerationProfile::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_AccelerationProfile::get_Execute, &MC_AccelerationProfile::set_Execute }, 
  {"ArraySize", 9, "INT", &MC_AccelerationProfile::get_ArraySize, &MC_AccelerationProfile::set_ArraySize }, 
  {"CommandAbort", 12, "BOOL", &MC_AccelerationProfile::get_CommandAbort, &MC_AccelerationProfile::set_CommandAbort }, 
  {"TimeAcceleration", 16, "MC_TA_REF", &MC_AccelerationProfile::get_TimeAcceleration, &MC_AccelerationProfile::set_TimeAcceleration }, 
  {"AccelerationScale", 17, "LREAL", &MC_AccelerationProfile::get_AccelerationScale, &MC_AccelerationProfile::set_AccelerationScale }, 
};
IEC_Property_Range MC_AccelerationProfile::property_range_list[] = { 
  {0, 3, 4 }, 
  {3, 1, 5 }, 
  {4, 2, 6 }, 
  {6, 2, 7 }, 
  {8, 1, 9 }, 
  {9, 1, 12 }, 
  {10, 1, 16 }, 
  {11, 1, 17 }, 
};

bool MC_AccelerationProfile::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
      ubjson_writer_write_kv_object_begin(writer_, "TimeAcceleration");
      TimeAcceleration.save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int16(writer_, "ArraySize", ((ArraySize)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "AccelerationScale", ((AccelerationScale)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Offset", ((Offset)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Done", ((Done)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "CommandAbort", ((CommandAbort)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_AccelerationProfile::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      conf_node_t* sub = conf_node_find_child(parent_, "TimeAcceleration");
      if (sub != nullptr) TimeAcceleration.load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ArraySize", &v_) == RET_OK)
        (ArraySize) = value_int16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "AccelerationScale", &v_) == RET_OK)
        (AccelerationScale) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Offset", &v_) == RET_OK)
        (Offset) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Done", &v_) == RET_OK)
        (Done) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "CommandAbort", &v_) == RET_OK)
        (CommandAbort) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_AccelerationProfile::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_AccelerationProfile::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_CamIn::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_CamIn::get_Master(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Master);
    return true;
  } else if (*name_ != '^' || Master == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Master->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_CamIn::get_Slave(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Slave);
    return true;
  } else if (*name_ != '^' || Slave == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Slave->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_CamIn::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_CamIn::get_MasterOffset(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((MasterOffset)));
  return true;
}
bool MC_CamIn::get_SlaveOffset(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((SlaveOffset)));
  return true;
}
bool MC_CamIn::get_MasterScaling(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((MasterScaling)));
  return true;
}
bool MC_CamIn::get_SlaveScaling(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((SlaveScaling)));
  return true;
}
bool MC_CamIn::get_StartMode(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((StartMode)));
  return true;
}
bool MC_CamIn::get_CamTableID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return CamTableID.get_(name_, v_, obj);
}
bool MC_CamIn::get_VelocityDiff(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((VelocityDiff)));
  return true;
}
bool MC_CamIn::get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Acceleration)));
  return true;
}
bool MC_CamIn::get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Deceleration)));
  return true;
}
bool MC_CamIn::get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Jerk)));
  return true;
}
bool MC_CamIn::get_TappetHysteresis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((TappetHysteresis)));
  return true;
}
bool MC_CamIn::get_InSync(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((InSync)));
  return true;
}
bool MC_CamIn::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_CamIn::get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((CommandAborted)));
  return true;
}
bool MC_CamIn::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_CamIn::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_CamIn::get_EndOfProfile(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((EndOfProfile)));
  return true;
}
bool MC_CamIn::get_Tappets(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return Tappets.get_(name_, v_, obj);
}
bool MC_CamIn::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_CamIn::set_Master(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Master = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Master == NULL) { return false; }

  return Master->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_CamIn::set_Slave(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Slave = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Slave == NULL) { return false; }

  return Slave->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_CamIn::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_CamIn::set_MasterOffset(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (MasterOffset) = value_double(v_);
  return true;
}
bool MC_CamIn::set_SlaveOffset(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (SlaveOffset) = value_double(v_);
  return true;
}
bool MC_CamIn::set_MasterScaling(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (MasterScaling) = value_double(v_);
  return true;
}
bool MC_CamIn::set_SlaveScaling(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (SlaveScaling) = value_double(v_);
  return true;
}
bool MC_CamIn::set_StartMode(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (StartMode) = (MC_STARTMODE)value_int16(v_);
  return true;
}
bool MC_CamIn::set_CamTableID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return CamTableID.set_(name_, v_, obj);
}
bool MC_CamIn::set_VelocityDiff(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (VelocityDiff) = value_double(v_);
  return true;
}
bool MC_CamIn::set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Acceleration) = value_double(v_);
  return true;
}
bool MC_CamIn::set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Deceleration) = value_double(v_);
  return true;
}
bool MC_CamIn::set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Jerk) = value_double(v_);
  return true;
}
bool MC_CamIn::set_TappetHysteresis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (TappetHysteresis) = value_double(v_);
  return true;
}
bool MC_CamIn::set_InSync(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (InSync) = value_bool(v_);
  return true;
}
bool MC_CamIn::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_CamIn::set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (CommandAborted) = value_bool(v_);
  return true;
}
bool MC_CamIn::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_CamIn::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}
bool MC_CamIn::set_EndOfProfile(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (EndOfProfile) = value_bool(v_);
  return true;
}
bool MC_CamIn::set_Tappets(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return Tappets.set_(name_, v_, obj);
}

IEC_Property<MC_CamIn> MC_CamIn::property_list[] = { 
  {"Busy", 4, "BOOL", &MC_CamIn::get_Busy, &MC_CamIn::set_Busy }, 
  {"Jerk", 4, "LREAL", &MC_CamIn::get_Jerk, &MC_CamIn::set_Jerk }, 
  {"Error", 5, "BOOL", &MC_CamIn::get_Error, &MC_CamIn::set_Error }, 
  {"Slave", 5, "POINTER TO AXIS_BASE", &MC_CamIn::get_Slave, &MC_CamIn::set_Slave }, 
  {"InSync", 6, "BOOL", &MC_CamIn::get_InSync, &MC_CamIn::set_InSync }, 
  {"Master", 6, "POINTER TO AXIS_BASE", &MC_CamIn::get_Master, &MC_CamIn::set_Master }, 
  {"native", 6, "ULINT", &MC_CamIn::get_native, &MC_CamIn::set_native }, 
  {"ErrorID", 7, "WORD", &MC_CamIn::get_ErrorID, &MC_CamIn::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_CamIn::get_Execute, &MC_CamIn::set_Execute }, 
  {"Tappets", 7, "ZMC_TappetData", &MC_CamIn::get_Tappets, &MC_CamIn::set_Tappets }, 
  {"StartMode", 9, "INT", &MC_CamIn::get_StartMode, &MC_CamIn::set_StartMode }, 
  {"CamTableID", 10, "MC_CAM_ID", &MC_CamIn::get_CamTableID, &MC_CamIn::set_CamTableID }, 
  {"SlaveOffset", 11, "LREAL", &MC_CamIn::get_SlaveOffset, &MC_CamIn::set_SlaveOffset }, 
  {"Acceleration", 12, "LREAL", &MC_CamIn::get_Acceleration, &MC_CamIn::set_Acceleration }, 
  {"Deceleration", 12, "LREAL", &MC_CamIn::get_Deceleration, &MC_CamIn::set_Deceleration }, 
  {"EndOfProfile", 12, "BOOL", &MC_CamIn::get_EndOfProfile, &MC_CamIn::set_EndOfProfile }, 
  {"MasterOffset", 12, "LREAL", &MC_CamIn::get_MasterOffset, &MC_CamIn::set_MasterOffset }, 
  {"SlaveScaling", 12, "LREAL", &MC_CamIn::get_SlaveScaling, &MC_CamIn::set_SlaveScaling }, 
  {"VelocityDiff", 12, "LREAL", &MC_CamIn::get_VelocityDiff, &MC_CamIn::set_VelocityDiff }, 
  {"MasterScaling", 13, "LREAL", &MC_CamIn::get_MasterScaling, &MC_CamIn::set_MasterScaling }, 
  {"CommandAborted", 14, "BOOL", &MC_CamIn::get_CommandAborted, &MC_CamIn::set_CommandAborted }, 
  {"TappetHysteresis", 16, "LREAL", &MC_CamIn::get_TappetHysteresis, &MC_CamIn::set_TappetHysteresis }, 
};
IEC_Property_Range MC_CamIn::property_range_list[] = { 
  {0, 2, 4 }, 
  {2, 2, 5 }, 
  {4, 3, 6 }, 
  {7, 3, 7 }, 
  {10, 1, 9 }, 
  {11, 1, 10 }, 
  {12, 1, 11 }, 
  {13, 6, 12 }, 
  {19, 1, 13 }, 
  {20, 1, 14 }, 
  {21, 1, 16 }, 
};

bool MC_CamIn::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Master != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Master");
      Master->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Slave != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Slave");
      Slave->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "MasterOffset", ((MasterOffset)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "SlaveOffset", ((SlaveOffset)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "MasterScaling", ((MasterScaling)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "SlaveScaling", ((SlaveScaling)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int16(writer_, "StartMode", ((StartMode)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
      ubjson_writer_write_kv_object_begin(writer_, "CamTableID");
      CamTableID.save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "VelocityDiff", ((VelocityDiff)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Acceleration", ((Acceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Deceleration", ((Deceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Jerk", ((Jerk)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "TappetHysteresis", ((TappetHysteresis)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "InSync", ((InSync)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "CommandAborted", ((CommandAborted)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "EndOfProfile", ((EndOfProfile)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
      ubjson_writer_write_kv_object_begin(writer_, "Tappets");
      Tappets.save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  return true;
}

bool MC_CamIn::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Master != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Master");
      if (sub != nullptr) Master->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Slave != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Slave");
      if (sub != nullptr) Slave->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "MasterOffset", &v_) == RET_OK)
        (MasterOffset) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "SlaveOffset", &v_) == RET_OK)
        (SlaveOffset) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "MasterScaling", &v_) == RET_OK)
        (MasterScaling) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "SlaveScaling", &v_) == RET_OK)
        (SlaveScaling) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "StartMode", &v_) == RET_OK)
        (StartMode) = (MC_STARTMODE)value_int16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      conf_node_t* sub = conf_node_find_child(parent_, "CamTableID");
      if (sub != nullptr) CamTableID.load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "VelocityDiff", &v_) == RET_OK)
        (VelocityDiff) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Acceleration", &v_) == RET_OK)
        (Acceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Deceleration", &v_) == RET_OK)
        (Deceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Jerk", &v_) == RET_OK)
        (Jerk) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "TappetHysteresis", &v_) == RET_OK)
        (TappetHysteresis) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "InSync", &v_) == RET_OK)
        (InSync) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "CommandAborted", &v_) == RET_OK)
        (CommandAborted) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "EndOfProfile", &v_) == RET_OK)
        (EndOfProfile) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Tappets");
      if (sub != nullptr) Tappets.load_(sub, type_, nullptr);
  }
  return true;
}

bool MC_CamIn::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_CamIn::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_CamOut::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_CamOut::get_Slave(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Slave);
    return true;
  } else if (*name_ != '^' || Slave == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Slave->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_CamOut::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_CamOut::get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Done)));
  return true;
}
bool MC_CamOut::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_CamOut::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_CamOut::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_CamOut::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_CamOut::set_Slave(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Slave = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Slave == NULL) { return false; }

  return Slave->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_CamOut::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_CamOut::set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Done) = value_bool(v_);
  return true;
}
bool MC_CamOut::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_CamOut::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_CamOut::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_CamOut> MC_CamOut::property_list[] = { 
  {"Busy", 4, "BOOL", &MC_CamOut::get_Busy, &MC_CamOut::set_Busy }, 
  {"Done", 4, "BOOL", &MC_CamOut::get_Done, &MC_CamOut::set_Done }, 
  {"Error", 5, "BOOL", &MC_CamOut::get_Error, &MC_CamOut::set_Error }, 
  {"Slave", 5, "POINTER TO AXIS_BASE", &MC_CamOut::get_Slave, &MC_CamOut::set_Slave }, 
  {"native", 6, "ULINT", &MC_CamOut::get_native, &MC_CamOut::set_native }, 
  {"ErrorID", 7, "WORD", &MC_CamOut::get_ErrorID, &MC_CamOut::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_CamOut::get_Execute, &MC_CamOut::set_Execute }, 
};
IEC_Property_Range MC_CamOut::property_range_list[] = { 
  {0, 2, 4 }, 
  {2, 2, 5 }, 
  {4, 1, 6 }, 
  {5, 2, 7 }, 
};

bool MC_CamOut::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Slave != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Slave");
      Slave->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Done", ((Done)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_CamOut::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Slave != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Slave");
      if (sub != nullptr) Slave->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Done", &v_) == RET_OK)
        (Done) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_CamOut::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_CamOut::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_CamTableSelect::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_CamTableSelect::get_Master(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Master);
    return true;
  } else if (*name_ != '^' || Master == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Master->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_CamTableSelect::get_Slave(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Slave);
    return true;
  } else if (*name_ != '^' || Slave == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Slave->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_CamTableSelect::get_CamTable(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, CamTable);
    return true;
  } else if (*name_ != '^' || CamTable == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return CamTable->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_CamTableSelect::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_CamTableSelect::get_Periodic(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Periodic)));
  return true;
}
bool MC_CamTableSelect::get_MasterAbsolute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((MasterAbsolute)));
  return true;
}
bool MC_CamTableSelect::get_SlaveAbsolute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((SlaveAbsolute)));
  return true;
}
bool MC_CamTableSelect::get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Done)));
  return true;
}
bool MC_CamTableSelect::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_CamTableSelect::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_CamTableSelect::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_CamTableSelect::get_CamTableID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return CamTableID.get_(name_, v_, obj);
}
bool MC_CamTableSelect::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_CamTableSelect::set_Master(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Master = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Master == NULL) { return false; }

  return Master->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_CamTableSelect::set_Slave(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Slave = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Slave == NULL) { return false; }

  return Slave->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_CamTableSelect::set_CamTable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    CamTable = static_cast<MC_CAM_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || CamTable == NULL) { return false; }

  return CamTable->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_CamTableSelect::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_CamTableSelect::set_Periodic(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Periodic) = value_bool(v_);
  return true;
}
bool MC_CamTableSelect::set_MasterAbsolute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (MasterAbsolute) = value_bool(v_);
  return true;
}
bool MC_CamTableSelect::set_SlaveAbsolute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (SlaveAbsolute) = value_bool(v_);
  return true;
}
bool MC_CamTableSelect::set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Done) = value_bool(v_);
  return true;
}
bool MC_CamTableSelect::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_CamTableSelect::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_CamTableSelect::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}
bool MC_CamTableSelect::set_CamTableID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return CamTableID.set_(name_, v_, obj);
}

IEC_Property<MC_CamTableSelect> MC_CamTableSelect::property_list[] = { 
  {"Busy", 4, "BOOL", &MC_CamTableSelect::get_Busy, &MC_CamTableSelect::set_Busy }, 
  {"Done", 4, "BOOL", &MC_CamTableSelect::get_Done, &MC_CamTableSelect::set_Done }, 
  {"Error", 5, "BOOL", &MC_CamTableSelect::get_Error, &MC_CamTableSelect::set_Error }, 
  {"Slave", 5, "POINTER TO AXIS_BASE", &MC_CamTableSelect::get_Slave, &MC_CamTableSelect::set_Slave }, 
  {"Master", 6, "POINTER TO AXIS_BASE", &MC_CamTableSelect::get_Master, &MC_CamTableSelect::set_Master }, 
  {"native", 6, "ULINT", &MC_CamTableSelect::get_native, &MC_CamTableSelect::set_native }, 
  {"ErrorID", 7, "WORD", &MC_CamTableSelect::get_ErrorID, &MC_CamTableSelect::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_CamTableSelect::get_Execute, &MC_CamTableSelect::set_Execute }, 
  {"CamTable", 8, "POINTER TO ZMC_CAM_TABLE", &MC_CamTableSelect::get_CamTable, &MC_CamTableSelect::set_CamTable }, 
  {"Periodic", 8, "BOOL", &MC_CamTableSelect::get_Periodic, &MC_CamTableSelect::set_Periodic }, 
  {"CamTableID", 10, "MC_CAM_ID", &MC_CamTableSelect::get_CamTableID, &MC_CamTableSelect::set_CamTableID }, 
  {"SlaveAbsolute", 13, "BOOL", &MC_CamTableSelect::get_SlaveAbsolute, &MC_CamTableSelect::set_SlaveAbsolute }, 
  {"MasterAbsolute", 14, "BOOL", &MC_CamTableSelect::get_MasterAbsolute, &MC_CamTableSelect::set_MasterAbsolute }, 
};
IEC_Property_Range MC_CamTableSelect::property_range_list[] = { 
  {0, 2, 4 }, 
  {2, 2, 5 }, 
  {4, 2, 6 }, 
  {6, 2, 7 }, 
  {8, 2, 8 }, 
  {10, 1, 10 }, 
  {11, 1, 13 }, 
  {12, 1, 14 }, 
};

bool MC_CamTableSelect::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Master != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Master");
      Master->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Slave != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Slave");
      Slave->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (CamTable != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "CamTable");
      CamTable->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Periodic", ((Periodic)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "MasterAbsolute", ((MasterAbsolute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "SlaveAbsolute", ((SlaveAbsolute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Done", ((Done)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
      ubjson_writer_write_kv_object_begin(writer_, "CamTableID");
      CamTableID.save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  return true;
}

bool MC_CamTableSelect::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Master != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Master");
      if (sub != nullptr) Master->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Slave != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Slave");
      if (sub != nullptr) Slave->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (CamTable != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "CamTable");
      if (sub != nullptr) CamTable->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Periodic", &v_) == RET_OK)
        (Periodic) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "MasterAbsolute", &v_) == RET_OK)
        (MasterAbsolute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "SlaveAbsolute", &v_) == RET_OK)
        (SlaveAbsolute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Done", &v_) == RET_OK)
        (Done) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      conf_node_t* sub = conf_node_find_child(parent_, "CamTableID");
      if (sub != nullptr) CamTableID.load_(sub, type_, nullptr);
  }
  return true;
}

bool MC_CamTableSelect::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_CamTableSelect::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_DigitalCamSwitch::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_DigitalCamSwitch::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_DigitalCamSwitch::get_Switches(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return Switches.get_(name_, v_, obj);
}
bool MC_DigitalCamSwitch::get_Outputs(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  const char* index_ = tk_str_skip_array_prefix(name_);
  if (index_ != NULL) {
    if (!Outputs.hasElement(index_)) { return false; }
    value_set_bool(v_, (Outputs.get(index_)));
  } else {
    wbuffer_t wb_;
    ubjson_writer_t ub_;
    wbuffer_init_extendable(&wb_);
    ubjson_writer_init(&ub_, (ubjson_write_callback_t)wbuffer_write_binary, &wb_);
    ubjson_writer_write_kv_array_begin(&ub_, "value_");
    for(int i0_ = 1; i0_ <= 32; i0_++) {
        st_ubjson_write_bool(&ub_, ((Outputs[i0_])));
    }
    ubjson_writer_write_array_end(&ub_);
    value_set_ubjson(v_, wb_.data, wb_.cursor);
    v_->free_handle = TRUE;
  }
  return true;
}
bool MC_DigitalCamSwitch::get_TrackOptions(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  const char* index_ = tk_str_skip_array_prefix(name_);
  if (index_ != NULL) {
    if (!TrackOptions.hasElement(index_)) { return false; }
    return TrackOptions.get(index_).get_(tk_str_skip_object_prefix(name_), v_, obj);
  } else {
    wbuffer_t wb_;
    ubjson_writer_t ub_;
    wbuffer_init_extendable(&wb_);
    ubjson_writer_init(&ub_, (ubjson_write_callback_t)wbuffer_write_binary, &wb_);
    ubjson_writer_write_kv_array_begin(&ub_, "value_");
    for(int i0_ = 1; i0_ <= 32; i0_++) {
        ubjson_writer_write_object_begin(&ub_);
        TrackOptions[i0_].save_(&ub_, IEC_SAVE_ALL, nullptr);
        ubjson_writer_write_object_end(&ub_);
    }
    ubjson_writer_write_array_end(&ub_);
    value_set_ubjson(v_, wb_.data, wb_.cursor);
    v_->free_handle = TRUE;
  }
  return true;
}
bool MC_DigitalCamSwitch::get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Enable)));
  return true;
}
bool MC_DigitalCamSwitch::get_EnableMask(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint32(v_, ((EnableMask)));
  return true;
}
bool MC_DigitalCamSwitch::get_TappetMode(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((TappetMode)));
  return true;
}
bool MC_DigitalCamSwitch::get_InOperation(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((InOperation)));
  return true;
}
bool MC_DigitalCamSwitch::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_DigitalCamSwitch::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_DigitalCamSwitch::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_DigitalCamSwitch::get_SwitchCorrupted(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((SwitchCorrupted)));
  return true;
}
bool MC_DigitalCamSwitch::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_DigitalCamSwitch::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_DigitalCamSwitch::set_Switches(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return Switches.set_(name_, v_, obj);
}
bool MC_DigitalCamSwitch::set_Outputs(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  const char* index_ = tk_str_skip_array_prefix(name_);
  if (index_ != NULL) {
    if (!Outputs.hasElement(index_)) { return false; }
    Outputs.set(index_, value_bool(v_));
    return true;
  }
  return false;
}
bool MC_DigitalCamSwitch::set_TrackOptions(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  const char* index_ = tk_str_skip_array_prefix(name_);
  if (index_ != NULL) {
    if (!TrackOptions.hasElement(index_)) { return false; }
    return TrackOptions.get(index_).set_(tk_str_skip_object_prefix(name_), v_, obj);
  }
  return false;
}
bool MC_DigitalCamSwitch::set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Enable) = value_bool(v_);
  return true;
}
bool MC_DigitalCamSwitch::set_EnableMask(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (EnableMask) = value_uint32(v_);
  return true;
}
bool MC_DigitalCamSwitch::set_TappetMode(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (TappetMode) = (MC_TAPPETMODE)value_int16(v_);
  return true;
}
bool MC_DigitalCamSwitch::set_InOperation(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (InOperation) = value_bool(v_);
  return true;
}
bool MC_DigitalCamSwitch::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_DigitalCamSwitch::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_DigitalCamSwitch::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}
bool MC_DigitalCamSwitch::set_SwitchCorrupted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (SwitchCorrupted) = value_int16(v_);
  return true;
}

IEC_Property<MC_DigitalCamSwitch> MC_DigitalCamSwitch::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_DigitalCamSwitch::get_Axis, &MC_DigitalCamSwitch::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_DigitalCamSwitch::get_Busy, &MC_DigitalCamSwitch::set_Busy }, 
  {"Error", 5, "BOOL", &MC_DigitalCamSwitch::get_Error, &MC_DigitalCamSwitch::set_Error }, 
  {"Enable", 6, "BOOL", &MC_DigitalCamSwitch::get_Enable, &MC_DigitalCamSwitch::set_Enable }, 
  {"native", 6, "ULINT", &MC_DigitalCamSwitch::get_native, &MC_DigitalCamSwitch::set_native }, 
  {"ErrorID", 7, "WORD", &MC_DigitalCamSwitch::get_ErrorID, &MC_DigitalCamSwitch::set_ErrorID }, 
  {"Outputs", 7, "ARRAY [1..32] OF BOOL", &MC_DigitalCamSwitch::get_Outputs, &MC_DigitalCamSwitch::set_Outputs }, 
  {"Switches", 8, "MC_CAMSWITCH_REF", &MC_DigitalCamSwitch::get_Switches, &MC_DigitalCamSwitch::set_Switches }, 
  {"EnableMask", 10, "DWORD", &MC_DigitalCamSwitch::get_EnableMask, &MC_DigitalCamSwitch::set_EnableMask }, 
  {"TappetMode", 10, "INT", &MC_DigitalCamSwitch::get_TappetMode, &MC_DigitalCamSwitch::set_TappetMode }, 
  {"InOperation", 11, "BOOL", &MC_DigitalCamSwitch::get_InOperation, &MC_DigitalCamSwitch::set_InOperation }, 
  {"TrackOptions", 12, "ARRAY [1..32] OF MC_TRACK_TR", &MC_DigitalCamSwitch::get_TrackOptions, &MC_DigitalCamSwitch::set_TrackOptions }, 
  {"SwitchCorrupted", 15, "INT", &MC_DigitalCamSwitch::get_SwitchCorrupted, &MC_DigitalCamSwitch::set_SwitchCorrupted }, 
};
IEC_Property_Range MC_DigitalCamSwitch::property_range_list[] = { 
  {0, 2, 4 }, 
  {2, 1, 5 }, 
  {3, 2, 6 }, 
  {5, 2, 7 }, 
  {7, 1, 8 }, 
  {8, 2, 10 }, 
  {10, 1, 11 }, 
  {11, 1, 12 }, 
  {12, 1, 15 }, 
};

bool MC_DigitalCamSwitch::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
      ubjson_writer_write_kv_object_begin(writer_, "Switches");
      Switches.save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if(type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) {
    ubjson_writer_write_kv_array_begin(writer_, "Outputs");
    for(int i0_ = 1; i0_ <= 32; i0_++) {
        st_ubjson_write_bool(writer_, ((Outputs[i0_])));
    }
    ubjson_writer_write_array_end(writer_);
  }
  if(type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) {
    ubjson_writer_write_kv_array_begin(writer_, "TrackOptions");
    for(int i0_ = 1; i0_ <= 32; i0_++) {
        ubjson_writer_write_object_begin(writer_);
        TrackOptions[i0_].save_(writer_, type_, nullptr);
        ubjson_writer_write_object_end(writer_);
    }
    ubjson_writer_write_array_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Enable", ((Enable)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint32(writer_, "EnableMask", ((EnableMask)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int16(writer_, "TappetMode", ((TappetMode)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "InOperation", ((InOperation)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int16(writer_, "SwitchCorrupted", ((SwitchCorrupted)));
  }
  return true;
}

bool MC_DigitalCamSwitch::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Switches");
      if (sub != nullptr) Switches.load_(sub, type_, nullptr);
  }
  if(type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) {
    conf_node_t* sub = conf_node_find_child(parent_, "Outputs");
    for(int i0_ = 1; i0_ <= 32 && sub != nullptr; i0_++) {
        if(conf_node_get_child_value_by_index(sub, i0_-1, &v_) == RET_OK)
          (Outputs[i0_]) = value_bool(&v_);
    }
  }
  if(type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) {
    conf_node_t* sub = conf_node_find_child(parent_, "TrackOptions");
    for(int i0_ = 1; i0_ <= 32 && sub != nullptr; i0_++) {
        conf_node_t* iter = conf_node_find_child_by_index(sub, i0_-1);
        if (iter != nullptr) TrackOptions[i0_].load_(iter, type_, nullptr);
    }
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Enable", &v_) == RET_OK)
        (Enable) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "EnableMask", &v_) == RET_OK)
        (EnableMask) = value_uint32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "TappetMode", &v_) == RET_OK)
        (TappetMode) = (MC_TAPPETMODE)value_int16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "InOperation", &v_) == RET_OK)
        (InOperation) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "SwitchCorrupted", &v_) == RET_OK)
        (SwitchCorrupted) = value_int16(&v_);
  }
  return true;
}

bool MC_DigitalCamSwitch::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_DigitalCamSwitch::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_GearIn::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_GearIn::get_Master(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Master);
    return true;
  } else if (*name_ != '^' || Master == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Master->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_GearIn::get_Slave(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Slave);
    return true;
  } else if (*name_ != '^' || Slave == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Slave->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_GearIn::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_GearIn::get_RatioNumerator(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int32(v_, ((RatioNumerator)));
  return true;
}
bool MC_GearIn::get_RatioDenominator(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint32(v_, ((RatioDenominator)));
  return true;
}
bool MC_GearIn::get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Acceleration)));
  return true;
}
bool MC_GearIn::get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Deceleration)));
  return true;
}
bool MC_GearIn::get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Jerk)));
  return true;
}
bool MC_GearIn::get_BufferMode(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((BufferMode)));
  return true;
}
bool MC_GearIn::get_InGear(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((InGear)));
  return true;
}
bool MC_GearIn::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_GearIn::get_Active(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Active)));
  return true;
}
bool MC_GearIn::get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((CommandAborted)));
  return true;
}
bool MC_GearIn::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_GearIn::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_GearIn::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_GearIn::set_Master(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Master = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Master == NULL) { return false; }

  return Master->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_GearIn::set_Slave(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Slave = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Slave == NULL) { return false; }

  return Slave->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_GearIn::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_GearIn::set_RatioNumerator(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (RatioNumerator) = value_int32(v_);
  return true;
}
bool MC_GearIn::set_RatioDenominator(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (RatioDenominator) = value_uint32(v_);
  return true;
}
bool MC_GearIn::set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Acceleration) = value_double(v_);
  return true;
}
bool MC_GearIn::set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Deceleration) = value_double(v_);
  return true;
}
bool MC_GearIn::set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Jerk) = value_double(v_);
  return true;
}
bool MC_GearIn::set_BufferMode(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (BufferMode) = (MC_BUFFER_MODE)value_uint16(v_);
  return true;
}
bool MC_GearIn::set_InGear(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (InGear) = value_bool(v_);
  return true;
}
bool MC_GearIn::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_GearIn::set_Active(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Active) = value_bool(v_);
  return true;
}
bool MC_GearIn::set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (CommandAborted) = value_bool(v_);
  return true;
}
bool MC_GearIn::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_GearIn::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_GearIn> MC_GearIn::property_list[] = { 
  {"Busy", 4, "BOOL", &MC_GearIn::get_Busy, &MC_GearIn::set_Busy }, 
  {"Jerk", 4, "LREAL", &MC_GearIn::get_Jerk, &MC_GearIn::set_Jerk }, 
  {"Error", 5, "BOOL", &MC_GearIn::get_Error, &MC_GearIn::set_Error }, 
  {"Slave", 5, "POINTER TO AXIS_BASE", &MC_GearIn::get_Slave, &MC_GearIn::set_Slave }, 
  {"Active", 6, "BOOL", &MC_GearIn::get_Active, &MC_GearIn::set_Active }, 
  {"InGear", 6, "BOOL", &MC_GearIn::get_InGear, &MC_GearIn::set_InGear }, 
  {"Master", 6, "POINTER TO AXIS_BASE", &MC_GearIn::get_Master, &MC_GearIn::set_Master }, 
  {"native", 6, "ULINT", &MC_GearIn::get_native, &MC_GearIn::set_native }, 
  {"ErrorID", 7, "WORD", &MC_GearIn::get_ErrorID, &MC_GearIn::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_GearIn::get_Execute, &MC_GearIn::set_Execute }, 
  {"BufferMode", 10, "WORD", &MC_GearIn::get_BufferMode, &MC_GearIn::set_BufferMode }, 
  {"Acceleration", 12, "LREAL", &MC_GearIn::get_Acceleration, &MC_GearIn::set_Acceleration }, 
  {"Deceleration", 12, "LREAL", &MC_GearIn::get_Deceleration, &MC_GearIn::set_Deceleration }, 
  {"CommandAborted", 14, "BOOL", &MC_GearIn::get_CommandAborted, &MC_GearIn::set_CommandAborted }, 
  {"RatioNumerator", 14, "DINT", &MC_GearIn::get_RatioNumerator, &MC_GearIn::set_RatioNumerator }, 
  {"RatioDenominator", 16, "UDINT", &MC_GearIn::get_RatioDenominator, &MC_GearIn::set_RatioDenominator }, 
};
IEC_Property_Range MC_GearIn::property_range_list[] = { 
  {0, 2, 4 }, 
  {2, 2, 5 }, 
  {4, 4, 6 }, 
  {8, 2, 7 }, 
  {10, 1, 10 }, 
  {11, 2, 12 }, 
  {13, 2, 14 }, 
  {15, 1, 16 }, 
};

bool MC_GearIn::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Master != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Master");
      Master->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Slave != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Slave");
      Slave->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int32(writer_, "RatioNumerator", ((RatioNumerator)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint32(writer_, "RatioDenominator", ((RatioDenominator)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Acceleration", ((Acceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Deceleration", ((Deceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Jerk", ((Jerk)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "BufferMode", ((BufferMode)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "InGear", ((InGear)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Active", ((Active)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "CommandAborted", ((CommandAborted)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_GearIn::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Master != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Master");
      if (sub != nullptr) Master->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Slave != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Slave");
      if (sub != nullptr) Slave->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "RatioNumerator", &v_) == RET_OK)
        (RatioNumerator) = value_int32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "RatioDenominator", &v_) == RET_OK)
        (RatioDenominator) = value_uint32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Acceleration", &v_) == RET_OK)
        (Acceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Deceleration", &v_) == RET_OK)
        (Deceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Jerk", &v_) == RET_OK)
        (Jerk) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "BufferMode", &v_) == RET_OK)
        (BufferMode) = (MC_BUFFER_MODE)value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "InGear", &v_) == RET_OK)
        (InGear) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Active", &v_) == RET_OK)
        (Active) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "CommandAborted", &v_) == RET_OK)
        (CommandAborted) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_GearIn::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_GearIn::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_GearInPos::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_GearInPos::get_Master(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Master);
    return true;
  } else if (*name_ != '^' || Master == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Master->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_GearInPos::get_Slave(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Slave);
    return true;
  } else if (*name_ != '^' || Slave == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Slave->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_GearInPos::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_GearInPos::get_RatioNumerator(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int32(v_, ((RatioNumerator)));
  return true;
}
bool MC_GearInPos::get_RatioDenominator(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int32(v_, ((RatioDenominator)));
  return true;
}
bool MC_GearInPos::get_MasterSyncPosition(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((MasterSyncPosition)));
  return true;
}
bool MC_GearInPos::get_SlaveSyncPosition(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((SlaveSyncPosition)));
  return true;
}
bool MC_GearInPos::get_MasterStartDistance(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((MasterStartDistance)));
  return true;
}
bool MC_GearInPos::get_BufferMode(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((BufferMode)));
  return true;
}
bool MC_GearInPos::get_AvoidReversal(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((AvoidReversal)));
  return true;
}
bool MC_GearInPos::get_StartSync(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((StartSync)));
  return true;
}
bool MC_GearInPos::get_InSync(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((InSync)));
  return true;
}
bool MC_GearInPos::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_GearInPos::get_Active(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Active)));
  return true;
}
bool MC_GearInPos::get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((CommandAborted)));
  return true;
}
bool MC_GearInPos::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_GearInPos::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_GearInPos::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_GearInPos::set_Master(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Master = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Master == NULL) { return false; }

  return Master->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_GearInPos::set_Slave(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Slave = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Slave == NULL) { return false; }

  return Slave->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_GearInPos::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_GearInPos::set_RatioNumerator(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (RatioNumerator) = value_int32(v_);
  return true;
}
bool MC_GearInPos::set_RatioDenominator(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (RatioDenominator) = value_int32(v_);
  return true;
}
bool MC_GearInPos::set_MasterSyncPosition(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (MasterSyncPosition) = value_double(v_);
  return true;
}
bool MC_GearInPos::set_SlaveSyncPosition(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (SlaveSyncPosition) = value_double(v_);
  return true;
}
bool MC_GearInPos::set_MasterStartDistance(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (MasterStartDistance) = value_double(v_);
  return true;
}
bool MC_GearInPos::set_BufferMode(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (BufferMode) = (MC_BUFFER_MODE)value_uint16(v_);
  return true;
}
bool MC_GearInPos::set_AvoidReversal(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (AvoidReversal) = value_bool(v_);
  return true;
}
bool MC_GearInPos::set_StartSync(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (StartSync) = value_bool(v_);
  return true;
}
bool MC_GearInPos::set_InSync(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (InSync) = value_bool(v_);
  return true;
}
bool MC_GearInPos::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_GearInPos::set_Active(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Active) = value_bool(v_);
  return true;
}
bool MC_GearInPos::set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (CommandAborted) = value_bool(v_);
  return true;
}
bool MC_GearInPos::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_GearInPos::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_GearInPos> MC_GearInPos::property_list[] = { 
  {"Busy", 4, "BOOL", &MC_GearInPos::get_Busy, &MC_GearInPos::set_Busy }, 
  {"Error", 5, "BOOL", &MC_GearInPos::get_Error, &MC_GearInPos::set_Error }, 
  {"Slave", 5, "POINTER TO AXIS_BASE", &MC_GearInPos::get_Slave, &MC_GearInPos::set_Slave }, 
  {"Active", 6, "BOOL", &MC_GearInPos::get_Active, &MC_GearInPos::set_Active }, 
  {"InSync", 6, "BOOL", &MC_GearInPos::get_InSync, &MC_GearInPos::set_InSync }, 
  {"Master", 6, "POINTER TO AXIS_BASE", &MC_GearInPos::get_Master, &MC_GearInPos::set_Master }, 
  {"native", 6, "ULINT", &MC_GearInPos::get_native, &MC_GearInPos::set_native }, 
  {"ErrorID", 7, "WORD", &MC_GearInPos::get_ErrorID, &MC_GearInPos::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_GearInPos::get_Execute, &MC_GearInPos::set_Execute }, 
  {"StartSync", 9, "BOOL", &MC_GearInPos::get_StartSync, &MC_GearInPos::set_StartSync }, 
  {"BufferMode", 10, "WORD", &MC_GearInPos::get_BufferMode, &MC_GearInPos::set_BufferMode }, 
  {"AvoidReversal", 13, "BOOL", &MC_GearInPos::get_AvoidReversal, &MC_GearInPos::set_AvoidReversal }, 
  {"CommandAborted", 14, "BOOL", &MC_GearInPos::get_CommandAborted, &MC_GearInPos::set_CommandAborted }, 
  {"RatioNumerator", 14, "DINT", &MC_GearInPos::get_RatioNumerator, &MC_GearInPos::set_RatioNumerator }, 
  {"RatioDenominator", 16, "DINT", &MC_GearInPos::get_RatioDenominator, &MC_GearInPos::set_RatioDenominator }, 
  {"SlaveSyncPosition", 17, "LREAL", &MC_GearInPos::get_SlaveSyncPosition, &MC_GearInPos::set_SlaveSyncPosition }, 
  {"MasterSyncPosition", 18, "LREAL", &MC_GearInPos::get_MasterSyncPosition, &MC_GearInPos::set_MasterSyncPosition }, 
  {"MasterStartDistance", 19, "LREAL", &MC_GearInPos::get_MasterStartDistance, &MC_GearInPos::set_MasterStartDistance }, 
};
IEC_Property_Range MC_GearInPos::property_range_list[] = { 
  {0, 1, 4 }, 
  {1, 2, 5 }, 
  {3, 4, 6 }, 
  {7, 2, 7 }, 
  {9, 1, 9 }, 
  {10, 1, 10 }, 
  {11, 1, 13 }, 
  {12, 2, 14 }, 
  {14, 1, 16 }, 
  {15, 1, 17 }, 
  {16, 1, 18 }, 
  {17, 1, 19 }, 
};

bool MC_GearInPos::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Master != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Master");
      Master->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Slave != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Slave");
      Slave->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int32(writer_, "RatioNumerator", ((RatioNumerator)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int32(writer_, "RatioDenominator", ((RatioDenominator)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "MasterSyncPosition", ((MasterSyncPosition)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "SlaveSyncPosition", ((SlaveSyncPosition)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "MasterStartDistance", ((MasterStartDistance)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "BufferMode", ((BufferMode)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "AvoidReversal", ((AvoidReversal)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "StartSync", ((StartSync)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "InSync", ((InSync)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Active", ((Active)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "CommandAborted", ((CommandAborted)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_GearInPos::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Master != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Master");
      if (sub != nullptr) Master->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Slave != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Slave");
      if (sub != nullptr) Slave->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "RatioNumerator", &v_) == RET_OK)
        (RatioNumerator) = value_int32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "RatioDenominator", &v_) == RET_OK)
        (RatioDenominator) = value_int32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "MasterSyncPosition", &v_) == RET_OK)
        (MasterSyncPosition) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "SlaveSyncPosition", &v_) == RET_OK)
        (SlaveSyncPosition) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "MasterStartDistance", &v_) == RET_OK)
        (MasterStartDistance) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "BufferMode", &v_) == RET_OK)
        (BufferMode) = (MC_BUFFER_MODE)value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "AvoidReversal", &v_) == RET_OK)
        (AvoidReversal) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "StartSync", &v_) == RET_OK)
        (StartSync) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "InSync", &v_) == RET_OK)
        (InSync) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Active", &v_) == RET_OK)
        (Active) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "CommandAborted", &v_) == RET_OK)
        (CommandAborted) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_GearInPos::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_GearInPos::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_GearOut::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_GearOut::get_Slave(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Slave);
    return true;
  } else if (*name_ != '^' || Slave == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Slave->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_GearOut::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_GearOut::get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Done)));
  return true;
}
bool MC_GearOut::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_GearOut::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_GearOut::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_GearOut::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_GearOut::set_Slave(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Slave = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Slave == NULL) { return false; }

  return Slave->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_GearOut::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_GearOut::set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Done) = value_bool(v_);
  return true;
}
bool MC_GearOut::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_GearOut::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_GearOut::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_GearOut> MC_GearOut::property_list[] = { 
  {"Busy", 4, "BOOL", &MC_GearOut::get_Busy, &MC_GearOut::set_Busy }, 
  {"Done", 4, "BOOL", &MC_GearOut::get_Done, &MC_GearOut::set_Done }, 
  {"Error", 5, "BOOL", &MC_GearOut::get_Error, &MC_GearOut::set_Error }, 
  {"Slave", 5, "POINTER TO AXIS_BASE", &MC_GearOut::get_Slave, &MC_GearOut::set_Slave }, 
  {"native", 6, "ULINT", &MC_GearOut::get_native, &MC_GearOut::set_native }, 
  {"ErrorID", 7, "WORD", &MC_GearOut::get_ErrorID, &MC_GearOut::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_GearOut::get_Execute, &MC_GearOut::set_Execute }, 
};
IEC_Property_Range MC_GearOut::property_range_list[] = { 
  {0, 2, 4 }, 
  {2, 2, 5 }, 
  {4, 1, 6 }, 
  {5, 2, 7 }, 
};

bool MC_GearOut::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Slave != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Slave");
      Slave->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Done", ((Done)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_GearOut::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Slave != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Slave");
      if (sub != nullptr) Slave->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Done", &v_) == RET_OK)
        (Done) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_GearOut::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_GearOut::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_Halt::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_Halt::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_Halt::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_Halt::get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Deceleration)));
  return true;
}
bool MC_Halt::get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Jerk)));
  return true;
}
bool MC_Halt::get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Done)));
  return true;
}
bool MC_Halt::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_Halt::get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((CommandAborted)));
  return true;
}
bool MC_Halt::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_Halt::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_Halt::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_Halt::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_Halt::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_Halt::set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Deceleration) = value_double(v_);
  return true;
}
bool MC_Halt::set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Jerk) = value_double(v_);
  return true;
}
bool MC_Halt::set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Done) = value_bool(v_);
  return true;
}
bool MC_Halt::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_Halt::set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (CommandAborted) = value_bool(v_);
  return true;
}
bool MC_Halt::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_Halt::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_Halt> MC_Halt::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_Halt::get_Axis, &MC_Halt::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_Halt::get_Busy, &MC_Halt::set_Busy }, 
  {"Done", 4, "BOOL", &MC_Halt::get_Done, &MC_Halt::set_Done }, 
  {"Jerk", 4, "LREAL", &MC_Halt::get_Jerk, &MC_Halt::set_Jerk }, 
  {"Error", 5, "BOOL", &MC_Halt::get_Error, &MC_Halt::set_Error }, 
  {"native", 6, "ULINT", &MC_Halt::get_native, &MC_Halt::set_native }, 
  {"ErrorID", 7, "WORD", &MC_Halt::get_ErrorID, &MC_Halt::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_Halt::get_Execute, &MC_Halt::set_Execute }, 
  {"Deceleration", 12, "LREAL", &MC_Halt::get_Deceleration, &MC_Halt::set_Deceleration }, 
  {"CommandAborted", 14, "BOOL", &MC_Halt::get_CommandAborted, &MC_Halt::set_CommandAborted }, 
};
IEC_Property_Range MC_Halt::property_range_list[] = { 
  {0, 4, 4 }, 
  {4, 1, 5 }, 
  {5, 1, 6 }, 
  {6, 2, 7 }, 
  {8, 1, 12 }, 
  {9, 1, 14 }, 
};

bool MC_Halt::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Deceleration", ((Deceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Jerk", ((Jerk)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Done", ((Done)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "CommandAborted", ((CommandAborted)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_Halt::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Deceleration", &v_) == RET_OK)
        (Deceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Jerk", &v_) == RET_OK)
        (Jerk) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Done", &v_) == RET_OK)
        (Done) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "CommandAborted", &v_) == RET_OK)
        (CommandAborted) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_Halt::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_Halt::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_Home::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_Home::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_Home::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_Home::get_Position(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Position)));
  return true;
}
bool MC_Home::get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Done)));
  return true;
}
bool MC_Home::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_Home::get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((CommandAborted)));
  return true;
}
bool MC_Home::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_Home::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_Home::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_Home::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_Home::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_Home::set_Position(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Position) = value_double(v_);
  return true;
}
bool MC_Home::set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Done) = value_bool(v_);
  return true;
}
bool MC_Home::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_Home::set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (CommandAborted) = value_bool(v_);
  return true;
}
bool MC_Home::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_Home::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_Home> MC_Home::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_Home::get_Axis, &MC_Home::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_Home::get_Busy, &MC_Home::set_Busy }, 
  {"Done", 4, "BOOL", &MC_Home::get_Done, &MC_Home::set_Done }, 
  {"Error", 5, "BOOL", &MC_Home::get_Error, &MC_Home::set_Error }, 
  {"native", 6, "ULINT", &MC_Home::get_native, &MC_Home::set_native }, 
  {"ErrorID", 7, "WORD", &MC_Home::get_ErrorID, &MC_Home::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_Home::get_Execute, &MC_Home::set_Execute }, 
  {"Position", 8, "LREAL", &MC_Home::get_Position, &MC_Home::set_Position }, 
  {"CommandAborted", 14, "BOOL", &MC_Home::get_CommandAborted, &MC_Home::set_CommandAborted }, 
};
IEC_Property_Range MC_Home::property_range_list[] = { 
  {0, 3, 4 }, 
  {3, 1, 5 }, 
  {4, 1, 6 }, 
  {5, 2, 7 }, 
  {7, 1, 8 }, 
  {8, 1, 14 }, 
};

bool MC_Home::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Position", ((Position)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Done", ((Done)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "CommandAborted", ((CommandAborted)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_Home::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Position", &v_) == RET_OK)
        (Position) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Done", &v_) == RET_OK)
        (Done) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "CommandAborted", &v_) == RET_OK)
        (CommandAborted) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_Home::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_Home::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_Jog::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_Jog::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_Jog::get_JogForward(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((JogForward)));
  return true;
}
bool MC_Jog::get_JogBackward(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((JogBackward)));
  return true;
}
bool MC_Jog::get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Velocity)));
  return true;
}
bool MC_Jog::get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Acceleration)));
  return true;
}
bool MC_Jog::get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Deceleration)));
  return true;
}
bool MC_Jog::get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Jerk)));
  return true;
}
bool MC_Jog::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_Jog::get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((CommandAborted)));
  return true;
}
bool MC_Jog::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_Jog::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_Jog::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_Jog::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_Jog::set_JogForward(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (JogForward) = value_bool(v_);
  return true;
}
bool MC_Jog::set_JogBackward(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (JogBackward) = value_bool(v_);
  return true;
}
bool MC_Jog::set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Velocity) = value_double(v_);
  return true;
}
bool MC_Jog::set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Acceleration) = value_double(v_);
  return true;
}
bool MC_Jog::set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Deceleration) = value_double(v_);
  return true;
}
bool MC_Jog::set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Jerk) = value_double(v_);
  return true;
}
bool MC_Jog::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_Jog::set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (CommandAborted) = value_bool(v_);
  return true;
}
bool MC_Jog::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_Jog::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_Jog> MC_Jog::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_Jog::get_Axis, &MC_Jog::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_Jog::get_Busy, &MC_Jog::set_Busy }, 
  {"Jerk", 4, "LREAL", &MC_Jog::get_Jerk, &MC_Jog::set_Jerk }, 
  {"Error", 5, "BOOL", &MC_Jog::get_Error, &MC_Jog::set_Error }, 
  {"native", 6, "ULINT", &MC_Jog::get_native, &MC_Jog::set_native }, 
  {"ErrorID", 7, "WORD", &MC_Jog::get_ErrorID, &MC_Jog::set_ErrorID }, 
  {"Velocity", 8, "LREAL", &MC_Jog::get_Velocity, &MC_Jog::set_Velocity }, 
  {"JogForward", 10, "BOOL", &MC_Jog::get_JogForward, &MC_Jog::set_JogForward }, 
  {"JogBackward", 11, "BOOL", &MC_Jog::get_JogBackward, &MC_Jog::set_JogBackward }, 
  {"Acceleration", 12, "LREAL", &MC_Jog::get_Acceleration, &MC_Jog::set_Acceleration }, 
  {"Deceleration", 12, "LREAL", &MC_Jog::get_Deceleration, &MC_Jog::set_Deceleration }, 
  {"CommandAborted", 14, "BOOL", &MC_Jog::get_CommandAborted, &MC_Jog::set_CommandAborted }, 
};
IEC_Property_Range MC_Jog::property_range_list[] = { 
  {0, 3, 4 }, 
  {3, 1, 5 }, 
  {4, 1, 6 }, 
  {5, 1, 7 }, 
  {6, 1, 8 }, 
  {7, 1, 10 }, 
  {8, 1, 11 }, 
  {9, 2, 12 }, 
  {11, 1, 14 }, 
};

bool MC_Jog::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "JogForward", ((JogForward)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "JogBackward", ((JogBackward)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Velocity", ((Velocity)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Acceleration", ((Acceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Deceleration", ((Deceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Jerk", ((Jerk)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "CommandAborted", ((CommandAborted)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_Jog::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "JogForward", &v_) == RET_OK)
        (JogForward) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "JogBackward", &v_) == RET_OK)
        (JogBackward) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Velocity", &v_) == RET_OK)
        (Velocity) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Acceleration", &v_) == RET_OK)
        (Acceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Deceleration", &v_) == RET_OK)
        (Deceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Jerk", &v_) == RET_OK)
        (Jerk) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "CommandAborted", &v_) == RET_OK)
        (CommandAborted) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_Jog::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_Jog::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_MoveAbsolute::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_MoveAbsolute::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_MoveAbsolute::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_MoveAbsolute::get_Position(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Position)));
  return true;
}
bool MC_MoveAbsolute::get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Velocity)));
  return true;
}
bool MC_MoveAbsolute::get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Acceleration)));
  return true;
}
bool MC_MoveAbsolute::get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Deceleration)));
  return true;
}
bool MC_MoveAbsolute::get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Jerk)));
  return true;
}
bool MC_MoveAbsolute::get_Direction(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((Direction)));
  return true;
}
bool MC_MoveAbsolute::get_BufferMode(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((BufferMode)));
  return true;
}
bool MC_MoveAbsolute::get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Done)));
  return true;
}
bool MC_MoveAbsolute::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_MoveAbsolute::get_Active(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Active)));
  return true;
}
bool MC_MoveAbsolute::get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((CommandAborted)));
  return true;
}
bool MC_MoveAbsolute::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_MoveAbsolute::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_MoveAbsolute::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_MoveAbsolute::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_MoveAbsolute::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_MoveAbsolute::set_Position(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Position) = value_double(v_);
  return true;
}
bool MC_MoveAbsolute::set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Velocity) = value_double(v_);
  return true;
}
bool MC_MoveAbsolute::set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Acceleration) = value_double(v_);
  return true;
}
bool MC_MoveAbsolute::set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Deceleration) = value_double(v_);
  return true;
}
bool MC_MoveAbsolute::set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Jerk) = value_double(v_);
  return true;
}
bool MC_MoveAbsolute::set_Direction(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Direction) = (MC_DIRECTION)value_int16(v_);
  return true;
}
bool MC_MoveAbsolute::set_BufferMode(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (BufferMode) = (MC_BUFFER_MODE)value_uint16(v_);
  return true;
}
bool MC_MoveAbsolute::set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Done) = value_bool(v_);
  return true;
}
bool MC_MoveAbsolute::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_MoveAbsolute::set_Active(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Active) = value_bool(v_);
  return true;
}
bool MC_MoveAbsolute::set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (CommandAborted) = value_bool(v_);
  return true;
}
bool MC_MoveAbsolute::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_MoveAbsolute::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_MoveAbsolute> MC_MoveAbsolute::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_MoveAbsolute::get_Axis, &MC_MoveAbsolute::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_MoveAbsolute::get_Busy, &MC_MoveAbsolute::set_Busy }, 
  {"Done", 4, "BOOL", &MC_MoveAbsolute::get_Done, &MC_MoveAbsolute::set_Done }, 
  {"Jerk", 4, "LREAL", &MC_MoveAbsolute::get_Jerk, &MC_MoveAbsolute::set_Jerk }, 
  {"Error", 5, "BOOL", &MC_MoveAbsolute::get_Error, &MC_MoveAbsolute::set_Error }, 
  {"Active", 6, "BOOL", &MC_MoveAbsolute::get_Active, &MC_MoveAbsolute::set_Active }, 
  {"native", 6, "ULINT", &MC_MoveAbsolute::get_native, &MC_MoveAbsolute::set_native }, 
  {"ErrorID", 7, "WORD", &MC_MoveAbsolute::get_ErrorID, &MC_MoveAbsolute::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_MoveAbsolute::get_Execute, &MC_MoveAbsolute::set_Execute }, 
  {"Position", 8, "LREAL", &MC_MoveAbsolute::get_Position, &MC_MoveAbsolute::set_Position }, 
  {"Velocity", 8, "LREAL", &MC_MoveAbsolute::get_Velocity, &MC_MoveAbsolute::set_Velocity }, 
  {"Direction", 9, "INT", &MC_MoveAbsolute::get_Direction, &MC_MoveAbsolute::set_Direction }, 
  {"BufferMode", 10, "WORD", &MC_MoveAbsolute::get_BufferMode, &MC_MoveAbsolute::set_BufferMode }, 
  {"Acceleration", 12, "LREAL", &MC_MoveAbsolute::get_Acceleration, &MC_MoveAbsolute::set_Acceleration }, 
  {"Deceleration", 12, "LREAL", &MC_MoveAbsolute::get_Deceleration, &MC_MoveAbsolute::set_Deceleration }, 
  {"CommandAborted", 14, "BOOL", &MC_MoveAbsolute::get_CommandAborted, &MC_MoveAbsolute::set_CommandAborted }, 
};
IEC_Property_Range MC_MoveAbsolute::property_range_list[] = { 
  {0, 4, 4 }, 
  {4, 1, 5 }, 
  {5, 2, 6 }, 
  {7, 2, 7 }, 
  {9, 2, 8 }, 
  {11, 1, 9 }, 
  {12, 1, 10 }, 
  {13, 2, 12 }, 
  {15, 1, 14 }, 
};

bool MC_MoveAbsolute::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Position", ((Position)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Velocity", ((Velocity)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Acceleration", ((Acceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Deceleration", ((Deceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Jerk", ((Jerk)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int16(writer_, "Direction", ((Direction)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "BufferMode", ((BufferMode)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Done", ((Done)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Active", ((Active)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "CommandAborted", ((CommandAborted)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_MoveAbsolute::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Position", &v_) == RET_OK)
        (Position) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Velocity", &v_) == RET_OK)
        (Velocity) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Acceleration", &v_) == RET_OK)
        (Acceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Deceleration", &v_) == RET_OK)
        (Deceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Jerk", &v_) == RET_OK)
        (Jerk) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Direction", &v_) == RET_OK)
        (Direction) = (MC_DIRECTION)value_int16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "BufferMode", &v_) == RET_OK)
        (BufferMode) = (MC_BUFFER_MODE)value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Done", &v_) == RET_OK)
        (Done) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Active", &v_) == RET_OK)
        (Active) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "CommandAborted", &v_) == RET_OK)
        (CommandAborted) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_MoveAbsolute::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_MoveAbsolute::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_MoveAdditive::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_MoveAdditive::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_MoveAdditive::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_MoveAdditive::get_Distance(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Distance)));
  return true;
}
bool MC_MoveAdditive::get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Velocity)));
  return true;
}
bool MC_MoveAdditive::get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Acceleration)));
  return true;
}
bool MC_MoveAdditive::get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Deceleration)));
  return true;
}
bool MC_MoveAdditive::get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Jerk)));
  return true;
}
bool MC_MoveAdditive::get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Done)));
  return true;
}
bool MC_MoveAdditive::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_MoveAdditive::get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((CommandAborted)));
  return true;
}
bool MC_MoveAdditive::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_MoveAdditive::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_MoveAdditive::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_MoveAdditive::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_MoveAdditive::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_MoveAdditive::set_Distance(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Distance) = value_double(v_);
  return true;
}
bool MC_MoveAdditive::set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Velocity) = value_double(v_);
  return true;
}
bool MC_MoveAdditive::set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Acceleration) = value_double(v_);
  return true;
}
bool MC_MoveAdditive::set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Deceleration) = value_double(v_);
  return true;
}
bool MC_MoveAdditive::set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Jerk) = value_double(v_);
  return true;
}
bool MC_MoveAdditive::set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Done) = value_bool(v_);
  return true;
}
bool MC_MoveAdditive::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_MoveAdditive::set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (CommandAborted) = value_bool(v_);
  return true;
}
bool MC_MoveAdditive::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_MoveAdditive::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_MoveAdditive> MC_MoveAdditive::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_MoveAdditive::get_Axis, &MC_MoveAdditive::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_MoveAdditive::get_Busy, &MC_MoveAdditive::set_Busy }, 
  {"Done", 4, "BOOL", &MC_MoveAdditive::get_Done, &MC_MoveAdditive::set_Done }, 
  {"Jerk", 4, "LREAL", &MC_MoveAdditive::get_Jerk, &MC_MoveAdditive::set_Jerk }, 
  {"Error", 5, "BOOL", &MC_MoveAdditive::get_Error, &MC_MoveAdditive::set_Error }, 
  {"native", 6, "ULINT", &MC_MoveAdditive::get_native, &MC_MoveAdditive::set_native }, 
  {"ErrorID", 7, "WORD", &MC_MoveAdditive::get_ErrorID, &MC_MoveAdditive::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_MoveAdditive::get_Execute, &MC_MoveAdditive::set_Execute }, 
  {"Distance", 8, "LREAL", &MC_MoveAdditive::get_Distance, &MC_MoveAdditive::set_Distance }, 
  {"Velocity", 8, "LREAL", &MC_MoveAdditive::get_Velocity, &MC_MoveAdditive::set_Velocity }, 
  {"Acceleration", 12, "LREAL", &MC_MoveAdditive::get_Acceleration, &MC_MoveAdditive::set_Acceleration }, 
  {"Deceleration", 12, "LREAL", &MC_MoveAdditive::get_Deceleration, &MC_MoveAdditive::set_Deceleration }, 
  {"CommandAborted", 14, "BOOL", &MC_MoveAdditive::get_CommandAborted, &MC_MoveAdditive::set_CommandAborted }, 
};
IEC_Property_Range MC_MoveAdditive::property_range_list[] = { 
  {0, 4, 4 }, 
  {4, 1, 5 }, 
  {5, 1, 6 }, 
  {6, 2, 7 }, 
  {8, 2, 8 }, 
  {10, 2, 12 }, 
  {12, 1, 14 }, 
};

bool MC_MoveAdditive::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Distance", ((Distance)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Velocity", ((Velocity)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Acceleration", ((Acceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Deceleration", ((Deceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Jerk", ((Jerk)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Done", ((Done)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "CommandAborted", ((CommandAborted)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_MoveAdditive::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Distance", &v_) == RET_OK)
        (Distance) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Velocity", &v_) == RET_OK)
        (Velocity) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Acceleration", &v_) == RET_OK)
        (Acceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Deceleration", &v_) == RET_OK)
        (Deceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Jerk", &v_) == RET_OK)
        (Jerk) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Done", &v_) == RET_OK)
        (Done) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "CommandAborted", &v_) == RET_OK)
        (CommandAborted) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_MoveAdditive::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_MoveAdditive::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_MoveContinuousAbsolute::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_MoveContinuousAbsolute::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_MoveContinuousAbsolute::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_MoveContinuousAbsolute::get_Position(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Position)));
  return true;
}
bool MC_MoveContinuousAbsolute::get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Velocity)));
  return true;
}
bool MC_MoveContinuousAbsolute::get_EndVelocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((EndVelocity)));
  return true;
}
bool MC_MoveContinuousAbsolute::get_EndVelocityDirection(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((EndVelocityDirection)));
  return true;
}
bool MC_MoveContinuousAbsolute::get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Acceleration)));
  return true;
}
bool MC_MoveContinuousAbsolute::get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Deceleration)));
  return true;
}
bool MC_MoveContinuousAbsolute::get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Jerk)));
  return true;
}
bool MC_MoveContinuousAbsolute::get_Direction(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((Direction)));
  return true;
}
bool MC_MoveContinuousAbsolute::get_AdaptEndVelToAvoidOvershoot(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((AdaptEndVelToAvoidOvershoot)));
  return true;
}
bool MC_MoveContinuousAbsolute::get_InEndVelocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((InEndVelocity)));
  return true;
}
bool MC_MoveContinuousAbsolute::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_MoveContinuousAbsolute::get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((CommandAborted)));
  return true;
}
bool MC_MoveContinuousAbsolute::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_MoveContinuousAbsolute::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_MoveContinuousAbsolute::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_MoveContinuousAbsolute::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_MoveContinuousAbsolute::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_MoveContinuousAbsolute::set_Position(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Position) = value_double(v_);
  return true;
}
bool MC_MoveContinuousAbsolute::set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Velocity) = value_double(v_);
  return true;
}
bool MC_MoveContinuousAbsolute::set_EndVelocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (EndVelocity) = value_double(v_);
  return true;
}
bool MC_MoveContinuousAbsolute::set_EndVelocityDirection(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (EndVelocityDirection) = value_uint16(v_);
  return true;
}
bool MC_MoveContinuousAbsolute::set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Acceleration) = value_double(v_);
  return true;
}
bool MC_MoveContinuousAbsolute::set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Deceleration) = value_double(v_);
  return true;
}
bool MC_MoveContinuousAbsolute::set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Jerk) = value_double(v_);
  return true;
}
bool MC_MoveContinuousAbsolute::set_Direction(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Direction) = (MC_DIRECTION)value_int16(v_);
  return true;
}
bool MC_MoveContinuousAbsolute::set_AdaptEndVelToAvoidOvershoot(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (AdaptEndVelToAvoidOvershoot) = value_bool(v_);
  return true;
}
bool MC_MoveContinuousAbsolute::set_InEndVelocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (InEndVelocity) = value_bool(v_);
  return true;
}
bool MC_MoveContinuousAbsolute::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_MoveContinuousAbsolute::set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (CommandAborted) = value_bool(v_);
  return true;
}
bool MC_MoveContinuousAbsolute::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_MoveContinuousAbsolute::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_MoveContinuousAbsolute> MC_MoveContinuousAbsolute::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_MoveContinuousAbsolute::get_Axis, &MC_MoveContinuousAbsolute::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_MoveContinuousAbsolute::get_Busy, &MC_MoveContinuousAbsolute::set_Busy }, 
  {"Jerk", 4, "LREAL", &MC_MoveContinuousAbsolute::get_Jerk, &MC_MoveContinuousAbsolute::set_Jerk }, 
  {"Error", 5, "BOOL", &MC_MoveContinuousAbsolute::get_Error, &MC_MoveContinuousAbsolute::set_Error }, 
  {"native", 6, "ULINT", &MC_MoveContinuousAbsolute::get_native, &MC_MoveContinuousAbsolute::set_native }, 
  {"ErrorID", 7, "WORD", &MC_MoveContinuousAbsolute::get_ErrorID, &MC_MoveContinuousAbsolute::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_MoveContinuousAbsolute::get_Execute, &MC_MoveContinuousAbsolute::set_Execute }, 
  {"Position", 8, "LREAL", &MC_MoveContinuousAbsolute::get_Position, &MC_MoveContinuousAbsolute::set_Position }, 
  {"Velocity", 8, "LREAL", &MC_MoveContinuousAbsolute::get_Velocity, &MC_MoveContinuousAbsolute::set_Velocity }, 
  {"Direction", 9, "INT", &MC_MoveContinuousAbsolute::get_Direction, &MC_MoveContinuousAbsolute::set_Direction }, 
  {"EndVelocity", 11, "LREAL", &MC_MoveContinuousAbsolute::get_EndVelocity, &MC_MoveContinuousAbsolute::set_EndVelocity }, 
  {"Acceleration", 12, "LREAL", &MC_MoveContinuousAbsolute::get_Acceleration, &MC_MoveContinuousAbsolute::set_Acceleration }, 
  {"Deceleration", 12, "LREAL", &MC_MoveContinuousAbsolute::get_Deceleration, &MC_MoveContinuousAbsolute::set_Deceleration }, 
  {"InEndVelocity", 13, "BOOL", &MC_MoveContinuousAbsolute::get_InEndVelocity, &MC_MoveContinuousAbsolute::set_InEndVelocity }, 
  {"CommandAborted", 14, "BOOL", &MC_MoveContinuousAbsolute::get_CommandAborted, &MC_MoveContinuousAbsolute::set_CommandAborted }, 
  {"EndVelocityDirection", 20, "WORD", &MC_MoveContinuousAbsolute::get_EndVelocityDirection, &MC_MoveContinuousAbsolute::set_EndVelocityDirection }, 
  {"AdaptEndVelToAvoidOvershoot", 27, "BOOL", &MC_MoveContinuousAbsolute::get_AdaptEndVelToAvoidOvershoot, &MC_MoveContinuousAbsolute::set_AdaptEndVelToAvoidOvershoot }, 
};
IEC_Property_Range MC_MoveContinuousAbsolute::property_range_list[] = { 
  {0, 3, 4 }, 
  {3, 1, 5 }, 
  {4, 1, 6 }, 
  {5, 2, 7 }, 
  {7, 2, 8 }, 
  {9, 1, 9 }, 
  {10, 1, 11 }, 
  {11, 2, 12 }, 
  {13, 1, 13 }, 
  {14, 1, 14 }, 
  {15, 1, 20 }, 
  {16, 1, 27 }, 
};

bool MC_MoveContinuousAbsolute::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Position", ((Position)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Velocity", ((Velocity)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "EndVelocity", ((EndVelocity)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "EndVelocityDirection", ((EndVelocityDirection)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Acceleration", ((Acceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Deceleration", ((Deceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Jerk", ((Jerk)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int16(writer_, "Direction", ((Direction)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "AdaptEndVelToAvoidOvershoot", ((AdaptEndVelToAvoidOvershoot)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "InEndVelocity", ((InEndVelocity)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "CommandAborted", ((CommandAborted)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_MoveContinuousAbsolute::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Position", &v_) == RET_OK)
        (Position) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Velocity", &v_) == RET_OK)
        (Velocity) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "EndVelocity", &v_) == RET_OK)
        (EndVelocity) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "EndVelocityDirection", &v_) == RET_OK)
        (EndVelocityDirection) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Acceleration", &v_) == RET_OK)
        (Acceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Deceleration", &v_) == RET_OK)
        (Deceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Jerk", &v_) == RET_OK)
        (Jerk) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Direction", &v_) == RET_OK)
        (Direction) = (MC_DIRECTION)value_int16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "AdaptEndVelToAvoidOvershoot", &v_) == RET_OK)
        (AdaptEndVelToAvoidOvershoot) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "InEndVelocity", &v_) == RET_OK)
        (InEndVelocity) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "CommandAborted", &v_) == RET_OK)
        (CommandAborted) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_MoveContinuousAbsolute::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_MoveContinuousAbsolute::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_MoveContinuousRelative::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_MoveContinuousRelative::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_MoveContinuousRelative::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_MoveContinuousRelative::get_Distance(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Distance)));
  return true;
}
bool MC_MoveContinuousRelative::get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Velocity)));
  return true;
}
bool MC_MoveContinuousRelative::get_EndVelocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((EndVelocity)));
  return true;
}
bool MC_MoveContinuousRelative::get_EndVelocityDirection(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((EndVelocityDirection)));
  return true;
}
bool MC_MoveContinuousRelative::get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Acceleration)));
  return true;
}
bool MC_MoveContinuousRelative::get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Deceleration)));
  return true;
}
bool MC_MoveContinuousRelative::get_InEndVelocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((InEndVelocity)));
  return true;
}
bool MC_MoveContinuousRelative::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_MoveContinuousRelative::get_CommandAbort(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((CommandAbort)));
  return true;
}
bool MC_MoveContinuousRelative::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_MoveContinuousRelative::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_MoveContinuousRelative::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_MoveContinuousRelative::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_MoveContinuousRelative::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_MoveContinuousRelative::set_Distance(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Distance) = value_double(v_);
  return true;
}
bool MC_MoveContinuousRelative::set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Velocity) = value_double(v_);
  return true;
}
bool MC_MoveContinuousRelative::set_EndVelocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (EndVelocity) = value_double(v_);
  return true;
}
bool MC_MoveContinuousRelative::set_EndVelocityDirection(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (EndVelocityDirection) = value_uint16(v_);
  return true;
}
bool MC_MoveContinuousRelative::set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Acceleration) = value_double(v_);
  return true;
}
bool MC_MoveContinuousRelative::set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Deceleration) = value_double(v_);
  return true;
}
bool MC_MoveContinuousRelative::set_InEndVelocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (InEndVelocity) = value_bool(v_);
  return true;
}
bool MC_MoveContinuousRelative::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_MoveContinuousRelative::set_CommandAbort(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (CommandAbort) = value_bool(v_);
  return true;
}
bool MC_MoveContinuousRelative::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_MoveContinuousRelative::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_MoveContinuousRelative> MC_MoveContinuousRelative::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_MoveContinuousRelative::get_Axis, &MC_MoveContinuousRelative::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_MoveContinuousRelative::get_Busy, &MC_MoveContinuousRelative::set_Busy }, 
  {"Error", 5, "BOOL", &MC_MoveContinuousRelative::get_Error, &MC_MoveContinuousRelative::set_Error }, 
  {"native", 6, "ULINT", &MC_MoveContinuousRelative::get_native, &MC_MoveContinuousRelative::set_native }, 
  {"ErrorID", 7, "WORD", &MC_MoveContinuousRelative::get_ErrorID, &MC_MoveContinuousRelative::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_MoveContinuousRelative::get_Execute, &MC_MoveContinuousRelative::set_Execute }, 
  {"Distance", 8, "LREAL", &MC_MoveContinuousRelative::get_Distance, &MC_MoveContinuousRelative::set_Distance }, 
  {"Velocity", 8, "LREAL", &MC_MoveContinuousRelative::get_Velocity, &MC_MoveContinuousRelative::set_Velocity }, 
  {"EndVelocity", 11, "LREAL", &MC_MoveContinuousRelative::get_EndVelocity, &MC_MoveContinuousRelative::set_EndVelocity }, 
  {"Acceleration", 12, "LREAL", &MC_MoveContinuousRelative::get_Acceleration, &MC_MoveContinuousRelative::set_Acceleration }, 
  {"CommandAbort", 12, "BOOL", &MC_MoveContinuousRelative::get_CommandAbort, &MC_MoveContinuousRelative::set_CommandAbort }, 
  {"Deceleration", 12, "LREAL", &MC_MoveContinuousRelative::get_Deceleration, &MC_MoveContinuousRelative::set_Deceleration }, 
  {"InEndVelocity", 13, "BOOL", &MC_MoveContinuousRelative::get_InEndVelocity, &MC_MoveContinuousRelative::set_InEndVelocity }, 
  {"EndVelocityDirection", 20, "WORD", &MC_MoveContinuousRelative::get_EndVelocityDirection, &MC_MoveContinuousRelative::set_EndVelocityDirection }, 
};
IEC_Property_Range MC_MoveContinuousRelative::property_range_list[] = { 
  {0, 2, 4 }, 
  {2, 1, 5 }, 
  {3, 1, 6 }, 
  {4, 2, 7 }, 
  {6, 2, 8 }, 
  {8, 1, 11 }, 
  {9, 3, 12 }, 
  {12, 1, 13 }, 
  {13, 1, 20 }, 
};

bool MC_MoveContinuousRelative::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Distance", ((Distance)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Velocity", ((Velocity)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "EndVelocity", ((EndVelocity)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "EndVelocityDirection", ((EndVelocityDirection)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Acceleration", ((Acceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Deceleration", ((Deceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "InEndVelocity", ((InEndVelocity)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "CommandAbort", ((CommandAbort)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_MoveContinuousRelative::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Distance", &v_) == RET_OK)
        (Distance) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Velocity", &v_) == RET_OK)
        (Velocity) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "EndVelocity", &v_) == RET_OK)
        (EndVelocity) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "EndVelocityDirection", &v_) == RET_OK)
        (EndVelocityDirection) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Acceleration", &v_) == RET_OK)
        (Acceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Deceleration", &v_) == RET_OK)
        (Deceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "InEndVelocity", &v_) == RET_OK)
        (InEndVelocity) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "CommandAbort", &v_) == RET_OK)
        (CommandAbort) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_MoveContinuousRelative::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_MoveContinuousRelative::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_MoveRelative::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_MoveRelative::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_MoveRelative::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_MoveRelative::get_Distance(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Distance)));
  return true;
}
bool MC_MoveRelative::get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Velocity)));
  return true;
}
bool MC_MoveRelative::get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Acceleration)));
  return true;
}
bool MC_MoveRelative::get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Deceleration)));
  return true;
}
bool MC_MoveRelative::get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Jerk)));
  return true;
}
bool MC_MoveRelative::get_BufferMode(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((BufferMode)));
  return true;
}
bool MC_MoveRelative::get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Done)));
  return true;
}
bool MC_MoveRelative::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_MoveRelative::get_Active(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Active)));
  return true;
}
bool MC_MoveRelative::get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((CommandAborted)));
  return true;
}
bool MC_MoveRelative::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_MoveRelative::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_MoveRelative::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_MoveRelative::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_MoveRelative::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_MoveRelative::set_Distance(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Distance) = value_double(v_);
  return true;
}
bool MC_MoveRelative::set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Velocity) = value_double(v_);
  return true;
}
bool MC_MoveRelative::set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Acceleration) = value_double(v_);
  return true;
}
bool MC_MoveRelative::set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Deceleration) = value_double(v_);
  return true;
}
bool MC_MoveRelative::set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Jerk) = value_double(v_);
  return true;
}
bool MC_MoveRelative::set_BufferMode(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (BufferMode) = (MC_BUFFER_MODE)value_uint16(v_);
  return true;
}
bool MC_MoveRelative::set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Done) = value_bool(v_);
  return true;
}
bool MC_MoveRelative::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_MoveRelative::set_Active(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Active) = value_bool(v_);
  return true;
}
bool MC_MoveRelative::set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (CommandAborted) = value_bool(v_);
  return true;
}
bool MC_MoveRelative::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_MoveRelative::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_MoveRelative> MC_MoveRelative::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_MoveRelative::get_Axis, &MC_MoveRelative::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_MoveRelative::get_Busy, &MC_MoveRelative::set_Busy }, 
  {"Done", 4, "BOOL", &MC_MoveRelative::get_Done, &MC_MoveRelative::set_Done }, 
  {"Jerk", 4, "LREAL", &MC_MoveRelative::get_Jerk, &MC_MoveRelative::set_Jerk }, 
  {"Error", 5, "BOOL", &MC_MoveRelative::get_Error, &MC_MoveRelative::set_Error }, 
  {"Active", 6, "BOOL", &MC_MoveRelative::get_Active, &MC_MoveRelative::set_Active }, 
  {"native", 6, "ULINT", &MC_MoveRelative::get_native, &MC_MoveRelative::set_native }, 
  {"ErrorID", 7, "WORD", &MC_MoveRelative::get_ErrorID, &MC_MoveRelative::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_MoveRelative::get_Execute, &MC_MoveRelative::set_Execute }, 
  {"Distance", 8, "LREAL", &MC_MoveRelative::get_Distance, &MC_MoveRelative::set_Distance }, 
  {"Velocity", 8, "LREAL", &MC_MoveRelative::get_Velocity, &MC_MoveRelative::set_Velocity }, 
  {"BufferMode", 10, "WORD", &MC_MoveRelative::get_BufferMode, &MC_MoveRelative::set_BufferMode }, 
  {"Acceleration", 12, "LREAL", &MC_MoveRelative::get_Acceleration, &MC_MoveRelative::set_Acceleration }, 
  {"Deceleration", 12, "LREAL", &MC_MoveRelative::get_Deceleration, &MC_MoveRelative::set_Deceleration }, 
  {"CommandAborted", 14, "BOOL", &MC_MoveRelative::get_CommandAborted, &MC_MoveRelative::set_CommandAborted }, 
};
IEC_Property_Range MC_MoveRelative::property_range_list[] = { 
  {0, 4, 4 }, 
  {4, 1, 5 }, 
  {5, 2, 6 }, 
  {7, 2, 7 }, 
  {9, 2, 8 }, 
  {11, 1, 10 }, 
  {12, 2, 12 }, 
  {14, 1, 14 }, 
};

bool MC_MoveRelative::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Distance", ((Distance)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Velocity", ((Velocity)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Acceleration", ((Acceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Deceleration", ((Deceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Jerk", ((Jerk)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "BufferMode", ((BufferMode)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Done", ((Done)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Active", ((Active)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "CommandAborted", ((CommandAborted)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_MoveRelative::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Distance", &v_) == RET_OK)
        (Distance) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Velocity", &v_) == RET_OK)
        (Velocity) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Acceleration", &v_) == RET_OK)
        (Acceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Deceleration", &v_) == RET_OK)
        (Deceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Jerk", &v_) == RET_OK)
        (Jerk) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "BufferMode", &v_) == RET_OK)
        (BufferMode) = (MC_BUFFER_MODE)value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Done", &v_) == RET_OK)
        (Done) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Active", &v_) == RET_OK)
        (Active) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "CommandAborted", &v_) == RET_OK)
        (CommandAborted) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_MoveRelative::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_MoveRelative::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_MoveSuperImposed::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_MoveSuperImposed::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_MoveSuperImposed::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_MoveSuperImposed::get_Distance(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Distance)));
  return true;
}
bool MC_MoveSuperImposed::get_VelocityDiff(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((VelocityDiff)));
  return true;
}
bool MC_MoveSuperImposed::get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Acceleration)));
  return true;
}
bool MC_MoveSuperImposed::get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Deceleration)));
  return true;
}
bool MC_MoveSuperImposed::get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Jerk)));
  return true;
}
bool MC_MoveSuperImposed::get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Done)));
  return true;
}
bool MC_MoveSuperImposed::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_MoveSuperImposed::get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((CommandAborted)));
  return true;
}
bool MC_MoveSuperImposed::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_MoveSuperImposed::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_MoveSuperImposed::get_SuperImposedVelocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((SuperImposedVelocity)));
  return true;
}
bool MC_MoveSuperImposed::get_SuperImposedAcceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((SuperImposedAcceleration)));
  return true;
}
bool MC_MoveSuperImposed::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_MoveSuperImposed::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_MoveSuperImposed::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_MoveSuperImposed::set_Distance(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Distance) = value_double(v_);
  return true;
}
bool MC_MoveSuperImposed::set_VelocityDiff(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (VelocityDiff) = value_double(v_);
  return true;
}
bool MC_MoveSuperImposed::set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Acceleration) = value_double(v_);
  return true;
}
bool MC_MoveSuperImposed::set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Deceleration) = value_double(v_);
  return true;
}
bool MC_MoveSuperImposed::set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Jerk) = value_double(v_);
  return true;
}
bool MC_MoveSuperImposed::set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Done) = value_bool(v_);
  return true;
}
bool MC_MoveSuperImposed::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_MoveSuperImposed::set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (CommandAborted) = value_bool(v_);
  return true;
}
bool MC_MoveSuperImposed::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_MoveSuperImposed::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}
bool MC_MoveSuperImposed::set_SuperImposedVelocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (SuperImposedVelocity) = value_double(v_);
  return true;
}
bool MC_MoveSuperImposed::set_SuperImposedAcceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (SuperImposedAcceleration) = value_double(v_);
  return true;
}

IEC_Property<MC_MoveSuperImposed> MC_MoveSuperImposed::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_MoveSuperImposed::get_Axis, &MC_MoveSuperImposed::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_MoveSuperImposed::get_Busy, &MC_MoveSuperImposed::set_Busy }, 
  {"Done", 4, "BOOL", &MC_MoveSuperImposed::get_Done, &MC_MoveSuperImposed::set_Done }, 
  {"Jerk", 4, "LREAL", &MC_MoveSuperImposed::get_Jerk, &MC_MoveSuperImposed::set_Jerk }, 
  {"Error", 5, "BOOL", &MC_MoveSuperImposed::get_Error, &MC_MoveSuperImposed::set_Error }, 
  {"native", 6, "ULINT", &MC_MoveSuperImposed::get_native, &MC_MoveSuperImposed::set_native }, 
  {"ErrorID", 7, "WORD", &MC_MoveSuperImposed::get_ErrorID, &MC_MoveSuperImposed::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_MoveSuperImposed::get_Execute, &MC_MoveSuperImposed::set_Execute }, 
  {"Distance", 8, "LREAL", &MC_MoveSuperImposed::get_Distance, &MC_MoveSuperImposed::set_Distance }, 
  {"Acceleration", 12, "LREAL", &MC_MoveSuperImposed::get_Acceleration, &MC_MoveSuperImposed::set_Acceleration }, 
  {"Deceleration", 12, "LREAL", &MC_MoveSuperImposed::get_Deceleration, &MC_MoveSuperImposed::set_Deceleration }, 
  {"VelocityDiff", 12, "LREAL", &MC_MoveSuperImposed::get_VelocityDiff, &MC_MoveSuperImposed::set_VelocityDiff }, 
  {"CommandAborted", 14, "BOOL", &MC_MoveSuperImposed::get_CommandAborted, &MC_MoveSuperImposed::set_CommandAborted }, 
  {"SuperImposedVelocity", 20, "LREAL", &MC_MoveSuperImposed::get_SuperImposedVelocity, &MC_MoveSuperImposed::set_SuperImposedVelocity }, 
  {"SuperImposedAcceleration", 24, "LREAL", &MC_MoveSuperImposed::get_SuperImposedAcceleration, &MC_MoveSuperImposed::set_SuperImposedAcceleration }, 
};
IEC_Property_Range MC_MoveSuperImposed::property_range_list[] = { 
  {0, 4, 4 }, 
  {4, 1, 5 }, 
  {5, 1, 6 }, 
  {6, 2, 7 }, 
  {8, 1, 8 }, 
  {9, 3, 12 }, 
  {12, 1, 14 }, 
  {13, 1, 20 }, 
  {14, 1, 24 }, 
};

bool MC_MoveSuperImposed::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Distance", ((Distance)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "VelocityDiff", ((VelocityDiff)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Acceleration", ((Acceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Deceleration", ((Deceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Jerk", ((Jerk)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Done", ((Done)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "CommandAborted", ((CommandAborted)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "SuperImposedVelocity", ((SuperImposedVelocity)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "SuperImposedAcceleration", ((SuperImposedAcceleration)));
  }
  return true;
}

bool MC_MoveSuperImposed::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Distance", &v_) == RET_OK)
        (Distance) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "VelocityDiff", &v_) == RET_OK)
        (VelocityDiff) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Acceleration", &v_) == RET_OK)
        (Acceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Deceleration", &v_) == RET_OK)
        (Deceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Jerk", &v_) == RET_OK)
        (Jerk) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Done", &v_) == RET_OK)
        (Done) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "CommandAborted", &v_) == RET_OK)
        (CommandAborted) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "SuperImposedVelocity", &v_) == RET_OK)
        (SuperImposedVelocity) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "SuperImposedAcceleration", &v_) == RET_OK)
        (SuperImposedAcceleration) = value_double(&v_);
  }
  return true;
}

bool MC_MoveSuperImposed::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_MoveSuperImposed::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_MoveVelocity::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_MoveVelocity::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_MoveVelocity::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_MoveVelocity::get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Velocity)));
  return true;
}
bool MC_MoveVelocity::get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Acceleration)));
  return true;
}
bool MC_MoveVelocity::get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Deceleration)));
  return true;
}
bool MC_MoveVelocity::get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Jerk)));
  return true;
}
bool MC_MoveVelocity::get_Direction(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((Direction)));
  return true;
}
bool MC_MoveVelocity::get_BufferMode(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((BufferMode)));
  return true;
}
bool MC_MoveVelocity::get_InVelocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((InVelocity)));
  return true;
}
bool MC_MoveVelocity::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_MoveVelocity::get_Active(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Active)));
  return true;
}
bool MC_MoveVelocity::get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((CommandAborted)));
  return true;
}
bool MC_MoveVelocity::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_MoveVelocity::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_MoveVelocity::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_MoveVelocity::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_MoveVelocity::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_MoveVelocity::set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Velocity) = value_double(v_);
  return true;
}
bool MC_MoveVelocity::set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Acceleration) = value_double(v_);
  return true;
}
bool MC_MoveVelocity::set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Deceleration) = value_double(v_);
  return true;
}
bool MC_MoveVelocity::set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Jerk) = value_double(v_);
  return true;
}
bool MC_MoveVelocity::set_Direction(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Direction) = (MC_DIRECTION)value_int16(v_);
  return true;
}
bool MC_MoveVelocity::set_BufferMode(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (BufferMode) = (MC_BUFFER_MODE)value_uint16(v_);
  return true;
}
bool MC_MoveVelocity::set_InVelocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (InVelocity) = value_bool(v_);
  return true;
}
bool MC_MoveVelocity::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_MoveVelocity::set_Active(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Active) = value_bool(v_);
  return true;
}
bool MC_MoveVelocity::set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (CommandAborted) = value_bool(v_);
  return true;
}
bool MC_MoveVelocity::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_MoveVelocity::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_MoveVelocity> MC_MoveVelocity::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_MoveVelocity::get_Axis, &MC_MoveVelocity::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_MoveVelocity::get_Busy, &MC_MoveVelocity::set_Busy }, 
  {"Jerk", 4, "LREAL", &MC_MoveVelocity::get_Jerk, &MC_MoveVelocity::set_Jerk }, 
  {"Error", 5, "BOOL", &MC_MoveVelocity::get_Error, &MC_MoveVelocity::set_Error }, 
  {"Active", 6, "BOOL", &MC_MoveVelocity::get_Active, &MC_MoveVelocity::set_Active }, 
  {"native", 6, "ULINT", &MC_MoveVelocity::get_native, &MC_MoveVelocity::set_native }, 
  {"ErrorID", 7, "WORD", &MC_MoveVelocity::get_ErrorID, &MC_MoveVelocity::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_MoveVelocity::get_Execute, &MC_MoveVelocity::set_Execute }, 
  {"Velocity", 8, "LREAL", &MC_MoveVelocity::get_Velocity, &MC_MoveVelocity::set_Velocity }, 
  {"Direction", 9, "INT", &MC_MoveVelocity::get_Direction, &MC_MoveVelocity::set_Direction }, 
  {"BufferMode", 10, "WORD", &MC_MoveVelocity::get_BufferMode, &MC_MoveVelocity::set_BufferMode }, 
  {"InVelocity", 10, "BOOL", &MC_MoveVelocity::get_InVelocity, &MC_MoveVelocity::set_InVelocity }, 
  {"Acceleration", 12, "LREAL", &MC_MoveVelocity::get_Acceleration, &MC_MoveVelocity::set_Acceleration }, 
  {"Deceleration", 12, "LREAL", &MC_MoveVelocity::get_Deceleration, &MC_MoveVelocity::set_Deceleration }, 
  {"CommandAborted", 14, "BOOL", &MC_MoveVelocity::get_CommandAborted, &MC_MoveVelocity::set_CommandAborted }, 
};
IEC_Property_Range MC_MoveVelocity::property_range_list[] = { 
  {0, 3, 4 }, 
  {3, 1, 5 }, 
  {4, 2, 6 }, 
  {6, 2, 7 }, 
  {8, 1, 8 }, 
  {9, 1, 9 }, 
  {10, 2, 10 }, 
  {12, 2, 12 }, 
  {14, 1, 14 }, 
};

bool MC_MoveVelocity::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Velocity", ((Velocity)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Acceleration", ((Acceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Deceleration", ((Deceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Jerk", ((Jerk)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int16(writer_, "Direction", ((Direction)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "BufferMode", ((BufferMode)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "InVelocity", ((InVelocity)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Active", ((Active)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "CommandAborted", ((CommandAborted)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_MoveVelocity::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Velocity", &v_) == RET_OK)
        (Velocity) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Acceleration", &v_) == RET_OK)
        (Acceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Deceleration", &v_) == RET_OK)
        (Deceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Jerk", &v_) == RET_OK)
        (Jerk) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Direction", &v_) == RET_OK)
        (Direction) = (MC_DIRECTION)value_int16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "BufferMode", &v_) == RET_OK)
        (BufferMode) = (MC_BUFFER_MODE)value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "InVelocity", &v_) == RET_OK)
        (InVelocity) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Active", &v_) == RET_OK)
        (Active) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "CommandAborted", &v_) == RET_OK)
        (CommandAborted) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_MoveVelocity::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_MoveVelocity::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_Phasing::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_Phasing::get_Master(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Master);
    return true;
  } else if (*name_ != '^' || Master == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Master->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_Phasing::get_Slave(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Slave);
    return true;
  } else if (*name_ != '^' || Slave == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Slave->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_Phasing::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_Phasing::get_PhaseShift(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((PhaseShift)));
  return true;
}
bool MC_Phasing::get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Velocity)));
  return true;
}
bool MC_Phasing::get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Acceleration)));
  return true;
}
bool MC_Phasing::get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Deceleration)));
  return true;
}
bool MC_Phasing::get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Jerk)));
  return true;
}
bool MC_Phasing::get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Done)));
  return true;
}
bool MC_Phasing::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_Phasing::get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((CommandAborted)));
  return true;
}
bool MC_Phasing::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_Phasing::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_Phasing::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_Phasing::set_Master(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Master = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Master == NULL) { return false; }

  return Master->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_Phasing::set_Slave(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Slave = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Slave == NULL) { return false; }

  return Slave->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_Phasing::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_Phasing::set_PhaseShift(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (PhaseShift) = value_double(v_);
  return true;
}
bool MC_Phasing::set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Velocity) = value_double(v_);
  return true;
}
bool MC_Phasing::set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Acceleration) = value_double(v_);
  return true;
}
bool MC_Phasing::set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Deceleration) = value_double(v_);
  return true;
}
bool MC_Phasing::set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Jerk) = value_double(v_);
  return true;
}
bool MC_Phasing::set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Done) = value_bool(v_);
  return true;
}
bool MC_Phasing::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_Phasing::set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (CommandAborted) = value_bool(v_);
  return true;
}
bool MC_Phasing::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_Phasing::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_Phasing> MC_Phasing::property_list[] = { 
  {"Busy", 4, "BOOL", &MC_Phasing::get_Busy, &MC_Phasing::set_Busy }, 
  {"Done", 4, "BOOL", &MC_Phasing::get_Done, &MC_Phasing::set_Done }, 
  {"Jerk", 4, "LREAL", &MC_Phasing::get_Jerk, &MC_Phasing::set_Jerk }, 
  {"Error", 5, "BOOL", &MC_Phasing::get_Error, &MC_Phasing::set_Error }, 
  {"Slave", 5, "POINTER TO AXIS_BASE", &MC_Phasing::get_Slave, &MC_Phasing::set_Slave }, 
  {"Master", 6, "POINTER TO AXIS_BASE", &MC_Phasing::get_Master, &MC_Phasing::set_Master }, 
  {"native", 6, "ULINT", &MC_Phasing::get_native, &MC_Phasing::set_native }, 
  {"ErrorID", 7, "WORD", &MC_Phasing::get_ErrorID, &MC_Phasing::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_Phasing::get_Execute, &MC_Phasing::set_Execute }, 
  {"Velocity", 8, "LREAL", &MC_Phasing::get_Velocity, &MC_Phasing::set_Velocity }, 
  {"PhaseShift", 10, "LREAL", &MC_Phasing::get_PhaseShift, &MC_Phasing::set_PhaseShift }, 
  {"Acceleration", 12, "LREAL", &MC_Phasing::get_Acceleration, &MC_Phasing::set_Acceleration }, 
  {"Deceleration", 12, "LREAL", &MC_Phasing::get_Deceleration, &MC_Phasing::set_Deceleration }, 
  {"CommandAborted", 14, "BOOL", &MC_Phasing::get_CommandAborted, &MC_Phasing::set_CommandAborted }, 
};
IEC_Property_Range MC_Phasing::property_range_list[] = { 
  {0, 3, 4 }, 
  {3, 2, 5 }, 
  {5, 2, 6 }, 
  {7, 2, 7 }, 
  {9, 1, 8 }, 
  {10, 1, 10 }, 
  {11, 2, 12 }, 
  {13, 1, 14 }, 
};

bool MC_Phasing::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Master != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Master");
      Master->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Slave != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Slave");
      Slave->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "PhaseShift", ((PhaseShift)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Velocity", ((Velocity)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Acceleration", ((Acceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Deceleration", ((Deceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Jerk", ((Jerk)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Done", ((Done)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "CommandAborted", ((CommandAborted)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_Phasing::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Master != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Master");
      if (sub != nullptr) Master->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Slave != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Slave");
      if (sub != nullptr) Slave->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "PhaseShift", &v_) == RET_OK)
        (PhaseShift) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Velocity", &v_) == RET_OK)
        (Velocity) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Acceleration", &v_) == RET_OK)
        (Acceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Deceleration", &v_) == RET_OK)
        (Deceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Jerk", &v_) == RET_OK)
        (Jerk) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Done", &v_) == RET_OK)
        (Done) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "CommandAborted", &v_) == RET_OK)
        (CommandAborted) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_Phasing::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_Phasing::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_PositionProfile::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_PositionProfile::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_PositionProfile::get_TimePosition(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return TimePosition.get_(name_, v_, obj);
}
bool MC_PositionProfile::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_PositionProfile::get_ArraySize(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((ArraySize)));
  return true;
}
bool MC_PositionProfile::get_PositionScale(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((PositionScale)));
  return true;
}
bool MC_PositionProfile::get_Offset(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Offset)));
  return true;
}
bool MC_PositionProfile::get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Done)));
  return true;
}
bool MC_PositionProfile::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_PositionProfile::get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((CommandAborted)));
  return true;
}
bool MC_PositionProfile::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_PositionProfile::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_PositionProfile::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_PositionProfile::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_PositionProfile::set_TimePosition(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return TimePosition.set_(name_, v_, obj);
}
bool MC_PositionProfile::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_PositionProfile::set_ArraySize(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ArraySize) = value_int16(v_);
  return true;
}
bool MC_PositionProfile::set_PositionScale(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (PositionScale) = value_double(v_);
  return true;
}
bool MC_PositionProfile::set_Offset(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Offset) = value_double(v_);
  return true;
}
bool MC_PositionProfile::set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Done) = value_bool(v_);
  return true;
}
bool MC_PositionProfile::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_PositionProfile::set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (CommandAborted) = value_bool(v_);
  return true;
}
bool MC_PositionProfile::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_PositionProfile::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_PositionProfile> MC_PositionProfile::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_PositionProfile::get_Axis, &MC_PositionProfile::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_PositionProfile::get_Busy, &MC_PositionProfile::set_Busy }, 
  {"Done", 4, "BOOL", &MC_PositionProfile::get_Done, &MC_PositionProfile::set_Done }, 
  {"Error", 5, "BOOL", &MC_PositionProfile::get_Error, &MC_PositionProfile::set_Error }, 
  {"Offset", 6, "LREAL", &MC_PositionProfile::get_Offset, &MC_PositionProfile::set_Offset }, 
  {"native", 6, "ULINT", &MC_PositionProfile::get_native, &MC_PositionProfile::set_native }, 
  {"ErrorID", 7, "WORD", &MC_PositionProfile::get_ErrorID, &MC_PositionProfile::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_PositionProfile::get_Execute, &MC_PositionProfile::set_Execute }, 
  {"ArraySize", 9, "INT", &MC_PositionProfile::get_ArraySize, &MC_PositionProfile::set_ArraySize }, 
  {"TimePosition", 12, "MC_TP_REF", &MC_PositionProfile::get_TimePosition, &MC_PositionProfile::set_TimePosition }, 
  {"PositionScale", 13, "LREAL", &MC_PositionProfile::get_PositionScale, &MC_PositionProfile::set_PositionScale }, 
  {"CommandAborted", 14, "BOOL", &MC_PositionProfile::get_CommandAborted, &MC_PositionProfile::set_CommandAborted }, 
};
IEC_Property_Range MC_PositionProfile::property_range_list[] = { 
  {0, 3, 4 }, 
  {3, 1, 5 }, 
  {4, 2, 6 }, 
  {6, 2, 7 }, 
  {8, 1, 9 }, 
  {9, 1, 12 }, 
  {10, 1, 13 }, 
  {11, 1, 14 }, 
};

bool MC_PositionProfile::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
      ubjson_writer_write_kv_object_begin(writer_, "TimePosition");
      TimePosition.save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int16(writer_, "ArraySize", ((ArraySize)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "PositionScale", ((PositionScale)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Offset", ((Offset)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Done", ((Done)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "CommandAborted", ((CommandAborted)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_PositionProfile::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      conf_node_t* sub = conf_node_find_child(parent_, "TimePosition");
      if (sub != nullptr) TimePosition.load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ArraySize", &v_) == RET_OK)
        (ArraySize) = value_int16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "PositionScale", &v_) == RET_OK)
        (PositionScale) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Offset", &v_) == RET_OK)
        (Offset) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Done", &v_) == RET_OK)
        (Done) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "CommandAborted", &v_) == RET_OK)
        (CommandAborted) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_PositionProfile::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_PositionProfile::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_Power::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_Power::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_Power::get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Enable)));
  return true;
}
bool MC_Power::get_bRegulatorOn(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bRegulatorOn)));
  return true;
}
bool MC_Power::get_bDriveStart(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bDriveStart)));
  return true;
}
bool MC_Power::get_Status(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Status)));
  return true;
}
bool MC_Power::get_bRegulatorRealState(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bRegulatorRealState)));
  return true;
}
bool MC_Power::get_bDriveRealState(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bDriveRealState)));
  return true;
}
bool MC_Power::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_Power::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_Power::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_Power::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_Power::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_Power::set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Enable) = value_bool(v_);
  return true;
}
bool MC_Power::set_bRegulatorOn(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bRegulatorOn) = value_bool(v_);
  return true;
}
bool MC_Power::set_bDriveStart(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bDriveStart) = value_bool(v_);
  return true;
}
bool MC_Power::set_Status(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Status) = value_bool(v_);
  return true;
}
bool MC_Power::set_bRegulatorRealState(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bRegulatorRealState) = value_bool(v_);
  return true;
}
bool MC_Power::set_bDriveRealState(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bDriveRealState) = value_bool(v_);
  return true;
}
bool MC_Power::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_Power::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_Power::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_Power> MC_Power::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_Power::get_Axis, &MC_Power::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_Power::get_Busy, &MC_Power::set_Busy }, 
  {"Error", 5, "BOOL", &MC_Power::get_Error, &MC_Power::set_Error }, 
  {"Enable", 6, "BOOL", &MC_Power::get_Enable, &MC_Power::set_Enable }, 
  {"Status", 6, "BOOL", &MC_Power::get_Status, &MC_Power::set_Status }, 
  {"native", 6, "ULINT", &MC_Power::get_native, &MC_Power::set_native }, 
  {"ErrorID", 7, "WORD", &MC_Power::get_ErrorID, &MC_Power::set_ErrorID }, 
  {"bDriveStart", 11, "BOOL", &MC_Power::get_bDriveStart, &MC_Power::set_bDriveStart }, 
  {"bRegulatorOn", 12, "BOOL", &MC_Power::get_bRegulatorOn, &MC_Power::set_bRegulatorOn }, 
  {"bDriveRealState", 15, "BOOL", &MC_Power::get_bDriveRealState, &MC_Power::set_bDriveRealState }, 
  {"bRegulatorRealState", 19, "BOOL", &MC_Power::get_bRegulatorRealState, &MC_Power::set_bRegulatorRealState }, 
};
IEC_Property_Range MC_Power::property_range_list[] = { 
  {0, 2, 4 }, 
  {2, 1, 5 }, 
  {3, 3, 6 }, 
  {6, 1, 7 }, 
  {7, 1, 11 }, 
  {8, 1, 12 }, 
  {9, 1, 15 }, 
  {10, 1, 19 }, 
};

bool MC_Power::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Enable", ((Enable)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bRegulatorOn", ((bRegulatorOn)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bDriveStart", ((bDriveStart)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Status", ((Status)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bRegulatorRealState", ((bRegulatorRealState)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bDriveRealState", ((bDriveRealState)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_Power::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Enable", &v_) == RET_OK)
        (Enable) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bRegulatorOn", &v_) == RET_OK)
        (bRegulatorOn) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bDriveStart", &v_) == RET_OK)
        (bDriveStart) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Status", &v_) == RET_OK)
        (Status) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bRegulatorRealState", &v_) == RET_OK)
        (bRegulatorRealState) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bDriveRealState", &v_) == RET_OK)
        (bDriveRealState) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_Power::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_Power::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_ReadActualPosition::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_ReadActualPosition::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_ReadActualPosition::get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Enable)));
  return true;
}
bool MC_ReadActualPosition::get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Valid)));
  return true;
}
bool MC_ReadActualPosition::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_ReadActualPosition::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_ReadActualPosition::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_ReadActualPosition::get_Position(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Position)));
  return true;
}
bool MC_ReadActualPosition::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_ReadActualPosition::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_ReadActualPosition::set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Enable) = value_bool(v_);
  return true;
}
bool MC_ReadActualPosition::set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Valid) = value_bool(v_);
  return true;
}
bool MC_ReadActualPosition::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_ReadActualPosition::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_ReadActualPosition::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}
bool MC_ReadActualPosition::set_Position(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Position) = value_double(v_);
  return true;
}

IEC_Property<MC_ReadActualPosition> MC_ReadActualPosition::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_ReadActualPosition::get_Axis, &MC_ReadActualPosition::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_ReadActualPosition::get_Busy, &MC_ReadActualPosition::set_Busy }, 
  {"Error", 5, "BOOL", &MC_ReadActualPosition::get_Error, &MC_ReadActualPosition::set_Error }, 
  {"Valid", 5, "BOOL", &MC_ReadActualPosition::get_Valid, &MC_ReadActualPosition::set_Valid }, 
  {"Enable", 6, "BOOL", &MC_ReadActualPosition::get_Enable, &MC_ReadActualPosition::set_Enable }, 
  {"native", 6, "ULINT", &MC_ReadActualPosition::get_native, &MC_ReadActualPosition::set_native }, 
  {"ErrorID", 7, "WORD", &MC_ReadActualPosition::get_ErrorID, &MC_ReadActualPosition::set_ErrorID }, 
  {"Position", 8, "LREAL", &MC_ReadActualPosition::get_Position, &MC_ReadActualPosition::set_Position }, 
};
IEC_Property_Range MC_ReadActualPosition::property_range_list[] = { 
  {0, 2, 4 }, 
  {2, 2, 5 }, 
  {4, 2, 6 }, 
  {6, 1, 7 }, 
  {7, 1, 8 }, 
};

bool MC_ReadActualPosition::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Enable", ((Enable)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Valid", ((Valid)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Position", ((Position)));
  }
  return true;
}

bool MC_ReadActualPosition::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Enable", &v_) == RET_OK)
        (Enable) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Valid", &v_) == RET_OK)
        (Valid) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Position", &v_) == RET_OK)
        (Position) = value_double(&v_);
  }
  return true;
}

bool MC_ReadActualPosition::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_ReadActualPosition::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_ReadActualTorque::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_ReadActualTorque::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_ReadActualTorque::get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Enable)));
  return true;
}
bool MC_ReadActualTorque::get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Valid)));
  return true;
}
bool MC_ReadActualTorque::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_ReadActualTorque::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_ReadActualTorque::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_ReadActualTorque::get_Torque(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Torque)));
  return true;
}
bool MC_ReadActualTorque::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_ReadActualTorque::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_ReadActualTorque::set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Enable) = value_bool(v_);
  return true;
}
bool MC_ReadActualTorque::set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Valid) = value_bool(v_);
  return true;
}
bool MC_ReadActualTorque::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_ReadActualTorque::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_ReadActualTorque::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}
bool MC_ReadActualTorque::set_Torque(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Torque) = value_double(v_);
  return true;
}

IEC_Property<MC_ReadActualTorque> MC_ReadActualTorque::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_ReadActualTorque::get_Axis, &MC_ReadActualTorque::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_ReadActualTorque::get_Busy, &MC_ReadActualTorque::set_Busy }, 
  {"Error", 5, "BOOL", &MC_ReadActualTorque::get_Error, &MC_ReadActualTorque::set_Error }, 
  {"Valid", 5, "BOOL", &MC_ReadActualTorque::get_Valid, &MC_ReadActualTorque::set_Valid }, 
  {"Enable", 6, "BOOL", &MC_ReadActualTorque::get_Enable, &MC_ReadActualTorque::set_Enable }, 
  {"Torque", 6, "LREAL", &MC_ReadActualTorque::get_Torque, &MC_ReadActualTorque::set_Torque }, 
  {"native", 6, "ULINT", &MC_ReadActualTorque::get_native, &MC_ReadActualTorque::set_native }, 
  {"ErrorID", 7, "WORD", &MC_ReadActualTorque::get_ErrorID, &MC_ReadActualTorque::set_ErrorID }, 
};
IEC_Property_Range MC_ReadActualTorque::property_range_list[] = { 
  {0, 2, 4 }, 
  {2, 2, 5 }, 
  {4, 3, 6 }, 
  {7, 1, 7 }, 
};

bool MC_ReadActualTorque::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Enable", ((Enable)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Valid", ((Valid)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Torque", ((Torque)));
  }
  return true;
}

bool MC_ReadActualTorque::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Enable", &v_) == RET_OK)
        (Enable) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Valid", &v_) == RET_OK)
        (Valid) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Torque", &v_) == RET_OK)
        (Torque) = value_double(&v_);
  }
  return true;
}

bool MC_ReadActualTorque::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_ReadActualTorque::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_ReadActualVelocity::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_ReadActualVelocity::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_ReadActualVelocity::get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Enable)));
  return true;
}
bool MC_ReadActualVelocity::get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Valid)));
  return true;
}
bool MC_ReadActualVelocity::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_ReadActualVelocity::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_ReadActualVelocity::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_ReadActualVelocity::get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Velocity)));
  return true;
}
bool MC_ReadActualVelocity::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_ReadActualVelocity::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_ReadActualVelocity::set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Enable) = value_bool(v_);
  return true;
}
bool MC_ReadActualVelocity::set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Valid) = value_bool(v_);
  return true;
}
bool MC_ReadActualVelocity::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_ReadActualVelocity::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_ReadActualVelocity::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}
bool MC_ReadActualVelocity::set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Velocity) = value_double(v_);
  return true;
}

IEC_Property<MC_ReadActualVelocity> MC_ReadActualVelocity::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_ReadActualVelocity::get_Axis, &MC_ReadActualVelocity::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_ReadActualVelocity::get_Busy, &MC_ReadActualVelocity::set_Busy }, 
  {"Error", 5, "BOOL", &MC_ReadActualVelocity::get_Error, &MC_ReadActualVelocity::set_Error }, 
  {"Valid", 5, "BOOL", &MC_ReadActualVelocity::get_Valid, &MC_ReadActualVelocity::set_Valid }, 
  {"Enable", 6, "BOOL", &MC_ReadActualVelocity::get_Enable, &MC_ReadActualVelocity::set_Enable }, 
  {"native", 6, "ULINT", &MC_ReadActualVelocity::get_native, &MC_ReadActualVelocity::set_native }, 
  {"ErrorID", 7, "WORD", &MC_ReadActualVelocity::get_ErrorID, &MC_ReadActualVelocity::set_ErrorID }, 
  {"Velocity", 8, "LREAL", &MC_ReadActualVelocity::get_Velocity, &MC_ReadActualVelocity::set_Velocity }, 
};
IEC_Property_Range MC_ReadActualVelocity::property_range_list[] = { 
  {0, 2, 4 }, 
  {2, 2, 5 }, 
  {4, 2, 6 }, 
  {6, 1, 7 }, 
  {7, 1, 8 }, 
};

bool MC_ReadActualVelocity::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Enable", ((Enable)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Valid", ((Valid)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Velocity", ((Velocity)));
  }
  return true;
}

bool MC_ReadActualVelocity::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Enable", &v_) == RET_OK)
        (Enable) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Valid", &v_) == RET_OK)
        (Valid) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Velocity", &v_) == RET_OK)
        (Velocity) = value_double(&v_);
  }
  return true;
}

bool MC_ReadActualVelocity::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_ReadActualVelocity::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_ReadAxisError::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_ReadAxisError::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_ReadAxisError::get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Enable)));
  return true;
}
bool MC_ReadAxisError::get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Valid)));
  return true;
}
bool MC_ReadAxisError::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_ReadAxisError::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_ReadAxisError::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_ReadAxisError::get_AxisError(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((AxisError)));
  return true;
}
bool MC_ReadAxisError::get_AxisErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint32(v_, ((AxisErrorID)));
  return true;
}
bool MC_ReadAxisError::get_SWEndSwitchActive(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((SWEndSwitchActive)));
  return true;
}
bool MC_ReadAxisError::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_ReadAxisError::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_ReadAxisError::set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Enable) = value_bool(v_);
  return true;
}
bool MC_ReadAxisError::set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Valid) = value_bool(v_);
  return true;
}
bool MC_ReadAxisError::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_ReadAxisError::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_ReadAxisError::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}
bool MC_ReadAxisError::set_AxisError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (AxisError) = value_bool(v_);
  return true;
}
bool MC_ReadAxisError::set_AxisErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (AxisErrorID) = value_uint32(v_);
  return true;
}
bool MC_ReadAxisError::set_SWEndSwitchActive(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (SWEndSwitchActive) = value_bool(v_);
  return true;
}

IEC_Property<MC_ReadAxisError> MC_ReadAxisError::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_ReadAxisError::get_Axis, &MC_ReadAxisError::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_ReadAxisError::get_Busy, &MC_ReadAxisError::set_Busy }, 
  {"Error", 5, "BOOL", &MC_ReadAxisError::get_Error, &MC_ReadAxisError::set_Error }, 
  {"Valid", 5, "BOOL", &MC_ReadAxisError::get_Valid, &MC_ReadAxisError::set_Valid }, 
  {"Enable", 6, "BOOL", &MC_ReadAxisError::get_Enable, &MC_ReadAxisError::set_Enable }, 
  {"native", 6, "ULINT", &MC_ReadAxisError::get_native, &MC_ReadAxisError::set_native }, 
  {"ErrorID", 7, "WORD", &MC_ReadAxisError::get_ErrorID, &MC_ReadAxisError::set_ErrorID }, 
  {"AxisError", 9, "BOOL", &MC_ReadAxisError::get_AxisError, &MC_ReadAxisError::set_AxisError }, 
  {"AxisErrorID", 11, "DWORD", &MC_ReadAxisError::get_AxisErrorID, &MC_ReadAxisError::set_AxisErrorID }, 
  {"SWEndSwitchActive", 17, "BOOL", &MC_ReadAxisError::get_SWEndSwitchActive, &MC_ReadAxisError::set_SWEndSwitchActive }, 
};
IEC_Property_Range MC_ReadAxisError::property_range_list[] = { 
  {0, 2, 4 }, 
  {2, 2, 5 }, 
  {4, 2, 6 }, 
  {6, 1, 7 }, 
  {7, 1, 9 }, 
  {8, 1, 11 }, 
  {9, 1, 17 }, 
};

bool MC_ReadAxisError::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Enable", ((Enable)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Valid", ((Valid)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "AxisError", ((AxisError)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint32(writer_, "AxisErrorID", ((AxisErrorID)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "SWEndSwitchActive", ((SWEndSwitchActive)));
  }
  return true;
}

bool MC_ReadAxisError::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Enable", &v_) == RET_OK)
        (Enable) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Valid", &v_) == RET_OK)
        (Valid) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "AxisError", &v_) == RET_OK)
        (AxisError) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "AxisErrorID", &v_) == RET_OK)
        (AxisErrorID) = value_uint32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "SWEndSwitchActive", &v_) == RET_OK)
        (SWEndSwitchActive) = value_bool(&v_);
  }
  return true;
}

bool MC_ReadAxisError::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_ReadAxisError::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_ReadBoolParameter::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_ReadBoolParameter::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_ReadBoolParameter::get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Enable)));
  return true;
}
bool MC_ReadBoolParameter::get_ParameterNumber(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int32(v_, ((ParameterNumber)));
  return true;
}
bool MC_ReadBoolParameter::get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Valid)));
  return true;
}
bool MC_ReadBoolParameter::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_ReadBoolParameter::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_ReadBoolParameter::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_ReadBoolParameter::get_Value(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Value)));
  return true;
}
bool MC_ReadBoolParameter::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_ReadBoolParameter::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_ReadBoolParameter::set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Enable) = value_bool(v_);
  return true;
}
bool MC_ReadBoolParameter::set_ParameterNumber(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ParameterNumber) = value_int32(v_);
  return true;
}
bool MC_ReadBoolParameter::set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Valid) = value_bool(v_);
  return true;
}
bool MC_ReadBoolParameter::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_ReadBoolParameter::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_ReadBoolParameter::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}
bool MC_ReadBoolParameter::set_Value(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Value) = value_bool(v_);
  return true;
}

IEC_Property<MC_ReadBoolParameter> MC_ReadBoolParameter::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_ReadBoolParameter::get_Axis, &MC_ReadBoolParameter::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_ReadBoolParameter::get_Busy, &MC_ReadBoolParameter::set_Busy }, 
  {"Error", 5, "BOOL", &MC_ReadBoolParameter::get_Error, &MC_ReadBoolParameter::set_Error }, 
  {"Valid", 5, "BOOL", &MC_ReadBoolParameter::get_Valid, &MC_ReadBoolParameter::set_Valid }, 
  {"Value", 5, "BOOL", &MC_ReadBoolParameter::get_Value, &MC_ReadBoolParameter::set_Value }, 
  {"Enable", 6, "BOOL", &MC_ReadBoolParameter::get_Enable, &MC_ReadBoolParameter::set_Enable }, 
  {"native", 6, "ULINT", &MC_ReadBoolParameter::get_native, &MC_ReadBoolParameter::set_native }, 
  {"ErrorID", 7, "WORD", &MC_ReadBoolParameter::get_ErrorID, &MC_ReadBoolParameter::set_ErrorID }, 
  {"ParameterNumber", 15, "DINT", &MC_ReadBoolParameter::get_ParameterNumber, &MC_ReadBoolParameter::set_ParameterNumber }, 
};
IEC_Property_Range MC_ReadBoolParameter::property_range_list[] = { 
  {0, 2, 4 }, 
  {2, 3, 5 }, 
  {5, 2, 6 }, 
  {7, 1, 7 }, 
  {8, 1, 15 }, 
};

bool MC_ReadBoolParameter::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Enable", ((Enable)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int32(writer_, "ParameterNumber", ((ParameterNumber)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Valid", ((Valid)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Value", ((Value)));
  }
  return true;
}

bool MC_ReadBoolParameter::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Enable", &v_) == RET_OK)
        (Enable) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ParameterNumber", &v_) == RET_OK)
        (ParameterNumber) = value_int32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Valid", &v_) == RET_OK)
        (Valid) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Value", &v_) == RET_OK)
        (Value) = value_bool(&v_);
  }
  return true;
}

bool MC_ReadBoolParameter::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_ReadBoolParameter::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_ReadCommandPosition::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_ReadCommandPosition::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_ReadCommandPosition::get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Enable)));
  return true;
}
bool MC_ReadCommandPosition::get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Valid)));
  return true;
}
bool MC_ReadCommandPosition::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_ReadCommandPosition::get_Position(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Position)));
  return true;
}
bool MC_ReadCommandPosition::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_ReadCommandPosition::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_ReadCommandPosition::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_ReadCommandPosition::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_ReadCommandPosition::set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Enable) = value_bool(v_);
  return true;
}
bool MC_ReadCommandPosition::set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Valid) = value_bool(v_);
  return true;
}
bool MC_ReadCommandPosition::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_ReadCommandPosition::set_Position(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Position) = value_double(v_);
  return true;
}
bool MC_ReadCommandPosition::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_ReadCommandPosition::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_ReadCommandPosition> MC_ReadCommandPosition::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_ReadCommandPosition::get_Axis, &MC_ReadCommandPosition::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_ReadCommandPosition::get_Busy, &MC_ReadCommandPosition::set_Busy }, 
  {"Error", 5, "BOOL", &MC_ReadCommandPosition::get_Error, &MC_ReadCommandPosition::set_Error }, 
  {"Valid", 5, "BOOL", &MC_ReadCommandPosition::get_Valid, &MC_ReadCommandPosition::set_Valid }, 
  {"Enable", 6, "BOOL", &MC_ReadCommandPosition::get_Enable, &MC_ReadCommandPosition::set_Enable }, 
  {"native", 6, "ULINT", &MC_ReadCommandPosition::get_native, &MC_ReadCommandPosition::set_native }, 
  {"ErrorID", 7, "WORD", &MC_ReadCommandPosition::get_ErrorID, &MC_ReadCommandPosition::set_ErrorID }, 
  {"Position", 8, "LREAL", &MC_ReadCommandPosition::get_Position, &MC_ReadCommandPosition::set_Position }, 
};
IEC_Property_Range MC_ReadCommandPosition::property_range_list[] = { 
  {0, 2, 4 }, 
  {2, 2, 5 }, 
  {4, 2, 6 }, 
  {6, 1, 7 }, 
  {7, 1, 8 }, 
};

bool MC_ReadCommandPosition::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Enable", ((Enable)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Valid", ((Valid)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Position", ((Position)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_ReadCommandPosition::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Enable", &v_) == RET_OK)
        (Enable) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Valid", &v_) == RET_OK)
        (Valid) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Position", &v_) == RET_OK)
        (Position) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_ReadCommandPosition::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_ReadCommandPosition::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_ReadParameter::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_ReadParameter::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_ReadParameter::get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Enable)));
  return true;
}
bool MC_ReadParameter::get_ParameterNumber(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int32(v_, ((ParameterNumber)));
  return true;
}
bool MC_ReadParameter::get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Valid)));
  return true;
}
bool MC_ReadParameter::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_ReadParameter::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_ReadParameter::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_ReadParameter::get_Value(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Value)));
  return true;
}
bool MC_ReadParameter::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_ReadParameter::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_ReadParameter::set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Enable) = value_bool(v_);
  return true;
}
bool MC_ReadParameter::set_ParameterNumber(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ParameterNumber) = value_int32(v_);
  return true;
}
bool MC_ReadParameter::set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Valid) = value_bool(v_);
  return true;
}
bool MC_ReadParameter::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_ReadParameter::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_ReadParameter::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}
bool MC_ReadParameter::set_Value(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Value) = value_double(v_);
  return true;
}

IEC_Property<MC_ReadParameter> MC_ReadParameter::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_ReadParameter::get_Axis, &MC_ReadParameter::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_ReadParameter::get_Busy, &MC_ReadParameter::set_Busy }, 
  {"Error", 5, "BOOL", &MC_ReadParameter::get_Error, &MC_ReadParameter::set_Error }, 
  {"Valid", 5, "BOOL", &MC_ReadParameter::get_Valid, &MC_ReadParameter::set_Valid }, 
  {"Value", 5, "LREAL", &MC_ReadParameter::get_Value, &MC_ReadParameter::set_Value }, 
  {"Enable", 6, "BOOL", &MC_ReadParameter::get_Enable, &MC_ReadParameter::set_Enable }, 
  {"native", 6, "ULINT", &MC_ReadParameter::get_native, &MC_ReadParameter::set_native }, 
  {"ErrorID", 7, "WORD", &MC_ReadParameter::get_ErrorID, &MC_ReadParameter::set_ErrorID }, 
  {"ParameterNumber", 15, "DINT", &MC_ReadParameter::get_ParameterNumber, &MC_ReadParameter::set_ParameterNumber }, 
};
IEC_Property_Range MC_ReadParameter::property_range_list[] = { 
  {0, 2, 4 }, 
  {2, 3, 5 }, 
  {5, 2, 6 }, 
  {7, 1, 7 }, 
  {8, 1, 15 }, 
};

bool MC_ReadParameter::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Enable", ((Enable)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int32(writer_, "ParameterNumber", ((ParameterNumber)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Valid", ((Valid)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Value", ((Value)));
  }
  return true;
}

bool MC_ReadParameter::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Enable", &v_) == RET_OK)
        (Enable) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ParameterNumber", &v_) == RET_OK)
        (ParameterNumber) = value_int32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Valid", &v_) == RET_OK)
        (Valid) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Value", &v_) == RET_OK)
        (Value) = value_double(&v_);
  }
  return true;
}

bool MC_ReadParameter::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_ReadParameter::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_ReadStatus::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_ReadStatus::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_ReadStatus::get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Enable)));
  return true;
}
bool MC_ReadStatus::get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Valid)));
  return true;
}
bool MC_ReadStatus::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_ReadStatus::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_ReadStatus::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_ReadStatus::get_Disabled(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Disabled)));
  return true;
}
bool MC_ReadStatus::get_ErrorStop(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((ErrorStop)));
  return true;
}
bool MC_ReadStatus::get_Stopping(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Stopping)));
  return true;
}
bool MC_ReadStatus::get_Standstill(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Standstill)));
  return true;
}
bool MC_ReadStatus::get_DiscreteMotion(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((DiscreteMotion)));
  return true;
}
bool MC_ReadStatus::get_ContinuousMotion(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((ContinuousMotion)));
  return true;
}
bool MC_ReadStatus::get_SynchronizedMotion(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((SynchronizedMotion)));
  return true;
}
bool MC_ReadStatus::get_Homing(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Homing)));
  return true;
}
bool MC_ReadStatus::get_ConstantVelocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((ConstantVelocity)));
  return true;
}
bool MC_ReadStatus::get_Accelerating(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Accelerating)));
  return true;
}
bool MC_ReadStatus::get_Decelerating(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Decelerating)));
  return true;
}
bool MC_ReadStatus::get_FBErrorOccurred(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((FBErrorOccurred)));
  return true;
}
bool MC_ReadStatus::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_ReadStatus::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_ReadStatus::set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Enable) = value_bool(v_);
  return true;
}
bool MC_ReadStatus::set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Valid) = value_bool(v_);
  return true;
}
bool MC_ReadStatus::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_ReadStatus::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_ReadStatus::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}
bool MC_ReadStatus::set_Disabled(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Disabled) = value_bool(v_);
  return true;
}
bool MC_ReadStatus::set_ErrorStop(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorStop) = value_bool(v_);
  return true;
}
bool MC_ReadStatus::set_Stopping(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Stopping) = value_bool(v_);
  return true;
}
bool MC_ReadStatus::set_Standstill(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Standstill) = value_bool(v_);
  return true;
}
bool MC_ReadStatus::set_DiscreteMotion(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (DiscreteMotion) = value_bool(v_);
  return true;
}
bool MC_ReadStatus::set_ContinuousMotion(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ContinuousMotion) = value_bool(v_);
  return true;
}
bool MC_ReadStatus::set_SynchronizedMotion(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (SynchronizedMotion) = value_bool(v_);
  return true;
}
bool MC_ReadStatus::set_Homing(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Homing) = value_bool(v_);
  return true;
}
bool MC_ReadStatus::set_ConstantVelocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ConstantVelocity) = value_bool(v_);
  return true;
}
bool MC_ReadStatus::set_Accelerating(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Accelerating) = value_bool(v_);
  return true;
}
bool MC_ReadStatus::set_Decelerating(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Decelerating) = value_bool(v_);
  return true;
}
bool MC_ReadStatus::set_FBErrorOccurred(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (FBErrorOccurred) = value_bool(v_);
  return true;
}

IEC_Property<MC_ReadStatus> MC_ReadStatus::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_ReadStatus::get_Axis, &MC_ReadStatus::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_ReadStatus::get_Busy, &MC_ReadStatus::set_Busy }, 
  {"Error", 5, "BOOL", &MC_ReadStatus::get_Error, &MC_ReadStatus::set_Error }, 
  {"Valid", 5, "BOOL", &MC_ReadStatus::get_Valid, &MC_ReadStatus::set_Valid }, 
  {"Enable", 6, "BOOL", &MC_ReadStatus::get_Enable, &MC_ReadStatus::set_Enable }, 
  {"Homing", 6, "BOOL", &MC_ReadStatus::get_Homing, &MC_ReadStatus::set_Homing }, 
  {"native", 6, "ULINT", &MC_ReadStatus::get_native, &MC_ReadStatus::set_native }, 
  {"ErrorID", 7, "WORD", &MC_ReadStatus::get_ErrorID, &MC_ReadStatus::set_ErrorID }, 
  {"Disabled", 8, "BOOL", &MC_ReadStatus::get_Disabled, &MC_ReadStatus::set_Disabled }, 
  {"Stopping", 8, "BOOL", &MC_ReadStatus::get_Stopping, &MC_ReadStatus::set_Stopping }, 
  {"ErrorStop", 9, "BOOL", &MC_ReadStatus::get_ErrorStop, &MC_ReadStatus::set_ErrorStop }, 
  {"Standstill", 10, "BOOL", &MC_ReadStatus::get_Standstill, &MC_ReadStatus::set_Standstill }, 
  {"Accelerating", 12, "BOOL", &MC_ReadStatus::get_Accelerating, &MC_ReadStatus::set_Accelerating }, 
  {"Decelerating", 12, "BOOL", &MC_ReadStatus::get_Decelerating, &MC_ReadStatus::set_Decelerating }, 
  {"DiscreteMotion", 14, "BOOL", &MC_ReadStatus::get_DiscreteMotion, &MC_ReadStatus::set_DiscreteMotion }, 
  {"FBErrorOccurred", 15, "BOOL", &MC_ReadStatus::get_FBErrorOccurred, &MC_ReadStatus::set_FBErrorOccurred }, 
  {"ConstantVelocity", 16, "BOOL", &MC_ReadStatus::get_ConstantVelocity, &MC_ReadStatus::set_ConstantVelocity }, 
  {"ContinuousMotion", 16, "BOOL", &MC_ReadStatus::get_ContinuousMotion, &MC_ReadStatus::set_ContinuousMotion }, 
  {"SynchronizedMotion", 18, "BOOL", &MC_ReadStatus::get_SynchronizedMotion, &MC_ReadStatus::set_SynchronizedMotion }, 
};
IEC_Property_Range MC_ReadStatus::property_range_list[] = { 
  {0, 2, 4 }, 
  {2, 2, 5 }, 
  {4, 3, 6 }, 
  {7, 1, 7 }, 
  {8, 2, 8 }, 
  {10, 1, 9 }, 
  {11, 1, 10 }, 
  {12, 2, 12 }, 
  {14, 1, 14 }, 
  {15, 1, 15 }, 
  {16, 2, 16 }, 
  {18, 1, 18 }, 
};

bool MC_ReadStatus::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Enable", ((Enable)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Valid", ((Valid)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Disabled", ((Disabled)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "ErrorStop", ((ErrorStop)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Stopping", ((Stopping)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Standstill", ((Standstill)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "DiscreteMotion", ((DiscreteMotion)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "ContinuousMotion", ((ContinuousMotion)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "SynchronizedMotion", ((SynchronizedMotion)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Homing", ((Homing)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "ConstantVelocity", ((ConstantVelocity)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Accelerating", ((Accelerating)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Decelerating", ((Decelerating)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "FBErrorOccurred", ((FBErrorOccurred)));
  }
  return true;
}

bool MC_ReadStatus::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Enable", &v_) == RET_OK)
        (Enable) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Valid", &v_) == RET_OK)
        (Valid) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Disabled", &v_) == RET_OK)
        (Disabled) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorStop", &v_) == RET_OK)
        (ErrorStop) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Stopping", &v_) == RET_OK)
        (Stopping) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Standstill", &v_) == RET_OK)
        (Standstill) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "DiscreteMotion", &v_) == RET_OK)
        (DiscreteMotion) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ContinuousMotion", &v_) == RET_OK)
        (ContinuousMotion) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "SynchronizedMotion", &v_) == RET_OK)
        (SynchronizedMotion) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Homing", &v_) == RET_OK)
        (Homing) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ConstantVelocity", &v_) == RET_OK)
        (ConstantVelocity) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Accelerating", &v_) == RET_OK)
        (Accelerating) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Decelerating", &v_) == RET_OK)
        (Decelerating) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "FBErrorOccurred", &v_) == RET_OK)
        (FBErrorOccurred) = value_bool(&v_);
  }
  return true;
}

bool MC_ReadStatus::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_ReadStatus::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_Reset::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_Reset::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_Reset::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_Reset::get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Done)));
  return true;
}
bool MC_Reset::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_Reset::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_Reset::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_Reset::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_Reset::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_Reset::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_Reset::set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Done) = value_bool(v_);
  return true;
}
bool MC_Reset::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_Reset::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_Reset::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_Reset> MC_Reset::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_Reset::get_Axis, &MC_Reset::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_Reset::get_Busy, &MC_Reset::set_Busy }, 
  {"Done", 4, "BOOL", &MC_Reset::get_Done, &MC_Reset::set_Done }, 
  {"Error", 5, "BOOL", &MC_Reset::get_Error, &MC_Reset::set_Error }, 
  {"native", 6, "ULINT", &MC_Reset::get_native, &MC_Reset::set_native }, 
  {"ErrorID", 7, "WORD", &MC_Reset::get_ErrorID, &MC_Reset::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_Reset::get_Execute, &MC_Reset::set_Execute }, 
};
IEC_Property_Range MC_Reset::property_range_list[] = { 
  {0, 3, 4 }, 
  {3, 1, 5 }, 
  {4, 1, 6 }, 
  {5, 2, 7 }, 
};

bool MC_Reset::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Done", ((Done)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_Reset::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Done", &v_) == RET_OK)
        (Done) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_Reset::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_Reset::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_SetPosition::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_SetPosition::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_SetPosition::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_SetPosition::get_Position(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Position)));
  return true;
}
bool MC_SetPosition::get_Mode(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Mode)));
  return true;
}
bool MC_SetPosition::get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Done)));
  return true;
}
bool MC_SetPosition::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_SetPosition::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_SetPosition::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_SetPosition::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_SetPosition::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_SetPosition::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_SetPosition::set_Position(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Position) = value_double(v_);
  return true;
}
bool MC_SetPosition::set_Mode(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Mode) = value_bool(v_);
  return true;
}
bool MC_SetPosition::set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Done) = value_bool(v_);
  return true;
}
bool MC_SetPosition::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_SetPosition::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_SetPosition::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_SetPosition> MC_SetPosition::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_SetPosition::get_Axis, &MC_SetPosition::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_SetPosition::get_Busy, &MC_SetPosition::set_Busy }, 
  {"Done", 4, "BOOL", &MC_SetPosition::get_Done, &MC_SetPosition::set_Done }, 
  {"Mode", 4, "BOOL", &MC_SetPosition::get_Mode, &MC_SetPosition::set_Mode }, 
  {"Error", 5, "BOOL", &MC_SetPosition::get_Error, &MC_SetPosition::set_Error }, 
  {"native", 6, "ULINT", &MC_SetPosition::get_native, &MC_SetPosition::set_native }, 
  {"ErrorID", 7, "WORD", &MC_SetPosition::get_ErrorID, &MC_SetPosition::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_SetPosition::get_Execute, &MC_SetPosition::set_Execute }, 
  {"Position", 8, "LREAL", &MC_SetPosition::get_Position, &MC_SetPosition::set_Position }, 
};
IEC_Property_Range MC_SetPosition::property_range_list[] = { 
  {0, 4, 4 }, 
  {4, 1, 5 }, 
  {5, 1, 6 }, 
  {6, 2, 7 }, 
  {8, 1, 8 }, 
};

bool MC_SetPosition::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Position", ((Position)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Mode", ((Mode)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Done", ((Done)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_SetPosition::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Position", &v_) == RET_OK)
        (Position) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Mode", &v_) == RET_OK)
        (Mode) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Done", &v_) == RET_OK)
        (Done) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_SetPosition::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_SetPosition::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_Stop::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_Stop::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_Stop::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_Stop::get_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Deceleration)));
  return true;
}
bool MC_Stop::get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Jerk)));
  return true;
}
bool MC_Stop::get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Done)));
  return true;
}
bool MC_Stop::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_Stop::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_Stop::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_Stop::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_Stop::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_Stop::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_Stop::set_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Deceleration) = value_double(v_);
  return true;
}
bool MC_Stop::set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Jerk) = value_double(v_);
  return true;
}
bool MC_Stop::set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Done) = value_bool(v_);
  return true;
}
bool MC_Stop::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_Stop::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_Stop::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_Stop> MC_Stop::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_Stop::get_Axis, &MC_Stop::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_Stop::get_Busy, &MC_Stop::set_Busy }, 
  {"Done", 4, "BOOL", &MC_Stop::get_Done, &MC_Stop::set_Done }, 
  {"Jerk", 4, "LREAL", &MC_Stop::get_Jerk, &MC_Stop::set_Jerk }, 
  {"Error", 5, "BOOL", &MC_Stop::get_Error, &MC_Stop::set_Error }, 
  {"native", 6, "ULINT", &MC_Stop::get_native, &MC_Stop::set_native }, 
  {"ErrorID", 7, "WORD", &MC_Stop::get_ErrorID, &MC_Stop::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_Stop::get_Execute, &MC_Stop::set_Execute }, 
  {"Deceleration", 12, "LREAL", &MC_Stop::get_Deceleration, &MC_Stop::set_Deceleration }, 
};
IEC_Property_Range MC_Stop::property_range_list[] = { 
  {0, 4, 4 }, 
  {4, 1, 5 }, 
  {5, 1, 6 }, 
  {6, 2, 7 }, 
  {8, 1, 12 }, 
};

bool MC_Stop::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Deceleration", ((Deceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Jerk", ((Jerk)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Done", ((Done)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_Stop::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Deceleration", &v_) == RET_OK)
        (Deceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Jerk", &v_) == RET_OK)
        (Jerk) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Done", &v_) == RET_OK)
        (Done) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_Stop::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_Stop::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_TouchProbe::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_TouchProbe::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_TouchProbe::get_TriggerInput(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return TriggerInput.get_(name_, v_, obj);
}
bool MC_TouchProbe::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_TouchProbe::get_WindowOnly(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((WindowOnly)));
  return true;
}
bool MC_TouchProbe::get_FirstPosition(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((FirstPosition)));
  return true;
}
bool MC_TouchProbe::get_LastPosition(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((LastPosition)));
  return true;
}
bool MC_TouchProbe::get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Done)));
  return true;
}
bool MC_TouchProbe::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_TouchProbe::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_TouchProbe::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_TouchProbe::get_RecordedPosition(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((RecordedPosition)));
  return true;
}
bool MC_TouchProbe::get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((CommandAborted)));
  return true;
}
bool MC_TouchProbe::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_TouchProbe::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_TouchProbe::set_TriggerInput(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return TriggerInput.set_(name_, v_, obj);
}
bool MC_TouchProbe::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_TouchProbe::set_WindowOnly(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (WindowOnly) = value_bool(v_);
  return true;
}
bool MC_TouchProbe::set_FirstPosition(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (FirstPosition) = value_double(v_);
  return true;
}
bool MC_TouchProbe::set_LastPosition(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (LastPosition) = value_double(v_);
  return true;
}
bool MC_TouchProbe::set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Done) = value_bool(v_);
  return true;
}
bool MC_TouchProbe::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_TouchProbe::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_TouchProbe::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}
bool MC_TouchProbe::set_RecordedPosition(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (RecordedPosition) = value_double(v_);
  return true;
}
bool MC_TouchProbe::set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (CommandAborted) = value_bool(v_);
  return true;
}

IEC_Property<MC_TouchProbe> MC_TouchProbe::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_TouchProbe::get_Axis, &MC_TouchProbe::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_TouchProbe::get_Busy, &MC_TouchProbe::set_Busy }, 
  {"Done", 4, "BOOL", &MC_TouchProbe::get_Done, &MC_TouchProbe::set_Done }, 
  {"Error", 5, "BOOL", &MC_TouchProbe::get_Error, &MC_TouchProbe::set_Error }, 
  {"native", 6, "ULINT", &MC_TouchProbe::get_native, &MC_TouchProbe::set_native }, 
  {"ErrorID", 7, "WORD", &MC_TouchProbe::get_ErrorID, &MC_TouchProbe::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_TouchProbe::get_Execute, &MC_TouchProbe::set_Execute }, 
  {"WindowOnly", 10, "BOOL", &MC_TouchProbe::get_WindowOnly, &MC_TouchProbe::set_WindowOnly }, 
  {"LastPosition", 12, "LREAL", &MC_TouchProbe::get_LastPosition, &MC_TouchProbe::set_LastPosition }, 
  {"TriggerInput", 12, "TRIGGER_REF", &MC_TouchProbe::get_TriggerInput, &MC_TouchProbe::set_TriggerInput }, 
  {"FirstPosition", 13, "LREAL", &MC_TouchProbe::get_FirstPosition, &MC_TouchProbe::set_FirstPosition }, 
  {"CommandAborted", 14, "BOOL", &MC_TouchProbe::get_CommandAborted, &MC_TouchProbe::set_CommandAborted }, 
  {"RecordedPosition", 16, "LREAL", &MC_TouchProbe::get_RecordedPosition, &MC_TouchProbe::set_RecordedPosition }, 
};
IEC_Property_Range MC_TouchProbe::property_range_list[] = { 
  {0, 3, 4 }, 
  {3, 1, 5 }, 
  {4, 1, 6 }, 
  {5, 2, 7 }, 
  {7, 1, 10 }, 
  {8, 2, 12 }, 
  {10, 1, 13 }, 
  {11, 1, 14 }, 
  {12, 1, 16 }, 
};

bool MC_TouchProbe::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
      ubjson_writer_write_kv_object_begin(writer_, "TriggerInput");
      TriggerInput.save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "WindowOnly", ((WindowOnly)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "FirstPosition", ((FirstPosition)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "LastPosition", ((LastPosition)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Done", ((Done)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "RecordedPosition", ((RecordedPosition)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "CommandAborted", ((CommandAborted)));
  }
  return true;
}

bool MC_TouchProbe::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      conf_node_t* sub = conf_node_find_child(parent_, "TriggerInput");
      if (sub != nullptr) TriggerInput.load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "WindowOnly", &v_) == RET_OK)
        (WindowOnly) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "FirstPosition", &v_) == RET_OK)
        (FirstPosition) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "LastPosition", &v_) == RET_OK)
        (LastPosition) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Done", &v_) == RET_OK)
        (Done) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "RecordedPosition", &v_) == RET_OK)
        (RecordedPosition) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "CommandAborted", &v_) == RET_OK)
        (CommandAborted) = value_bool(&v_);
  }
  return true;
}

bool MC_TouchProbe::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_TouchProbe::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_VelocityProfile::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_VelocityProfile::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_VelocityProfile::get_TimeVelocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return TimeVelocity.get_(name_, v_, obj);
}
bool MC_VelocityProfile::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_VelocityProfile::get_ArraySize(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((ArraySize)));
  return true;
}
bool MC_VelocityProfile::get_VelocityScale(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((VelocityScale)));
  return true;
}
bool MC_VelocityProfile::get_Offset(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Offset)));
  return true;
}
bool MC_VelocityProfile::get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Done)));
  return true;
}
bool MC_VelocityProfile::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_VelocityProfile::get_CommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((CommandAborted)));
  return true;
}
bool MC_VelocityProfile::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_VelocityProfile::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_VelocityProfile::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_VelocityProfile::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_VelocityProfile::set_TimeVelocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return TimeVelocity.set_(name_, v_, obj);
}
bool MC_VelocityProfile::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_VelocityProfile::set_ArraySize(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ArraySize) = value_int16(v_);
  return true;
}
bool MC_VelocityProfile::set_VelocityScale(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (VelocityScale) = value_double(v_);
  return true;
}
bool MC_VelocityProfile::set_Offset(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Offset) = value_double(v_);
  return true;
}
bool MC_VelocityProfile::set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Done) = value_bool(v_);
  return true;
}
bool MC_VelocityProfile::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_VelocityProfile::set_CommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (CommandAborted) = value_bool(v_);
  return true;
}
bool MC_VelocityProfile::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_VelocityProfile::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_VelocityProfile> MC_VelocityProfile::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_VelocityProfile::get_Axis, &MC_VelocityProfile::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_VelocityProfile::get_Busy, &MC_VelocityProfile::set_Busy }, 
  {"Done", 4, "BOOL", &MC_VelocityProfile::get_Done, &MC_VelocityProfile::set_Done }, 
  {"Error", 5, "BOOL", &MC_VelocityProfile::get_Error, &MC_VelocityProfile::set_Error }, 
  {"Offset", 6, "LREAL", &MC_VelocityProfile::get_Offset, &MC_VelocityProfile::set_Offset }, 
  {"native", 6, "ULINT", &MC_VelocityProfile::get_native, &MC_VelocityProfile::set_native }, 
  {"ErrorID", 7, "WORD", &MC_VelocityProfile::get_ErrorID, &MC_VelocityProfile::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_VelocityProfile::get_Execute, &MC_VelocityProfile::set_Execute }, 
  {"ArraySize", 9, "INT", &MC_VelocityProfile::get_ArraySize, &MC_VelocityProfile::set_ArraySize }, 
  {"TimeVelocity", 12, "MC_TV_REF", &MC_VelocityProfile::get_TimeVelocity, &MC_VelocityProfile::set_TimeVelocity }, 
  {"VelocityScale", 13, "LREAL", &MC_VelocityProfile::get_VelocityScale, &MC_VelocityProfile::set_VelocityScale }, 
  {"CommandAborted", 14, "BOOL", &MC_VelocityProfile::get_CommandAborted, &MC_VelocityProfile::set_CommandAborted }, 
};
IEC_Property_Range MC_VelocityProfile::property_range_list[] = { 
  {0, 3, 4 }, 
  {3, 1, 5 }, 
  {4, 2, 6 }, 
  {6, 2, 7 }, 
  {8, 1, 9 }, 
  {9, 1, 12 }, 
  {10, 1, 13 }, 
  {11, 1, 14 }, 
};

bool MC_VelocityProfile::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
      ubjson_writer_write_kv_object_begin(writer_, "TimeVelocity");
      TimeVelocity.save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int16(writer_, "ArraySize", ((ArraySize)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "VelocityScale", ((VelocityScale)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Offset", ((Offset)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Done", ((Done)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "CommandAborted", ((CommandAborted)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_VelocityProfile::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      conf_node_t* sub = conf_node_find_child(parent_, "TimeVelocity");
      if (sub != nullptr) TimeVelocity.load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ArraySize", &v_) == RET_OK)
        (ArraySize) = value_int16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "VelocityScale", &v_) == RET_OK)
        (VelocityScale) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Offset", &v_) == RET_OK)
        (Offset) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Done", &v_) == RET_OK)
        (Done) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "CommandAborted", &v_) == RET_OK)
        (CommandAborted) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_VelocityProfile::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_VelocityProfile::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_WriteBoolParameter::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_WriteBoolParameter::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_WriteBoolParameter::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_WriteBoolParameter::get_ParameterNumber(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int32(v_, ((ParameterNumber)));
  return true;
}
bool MC_WriteBoolParameter::get_Value(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Value)));
  return true;
}
bool MC_WriteBoolParameter::get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Done)));
  return true;
}
bool MC_WriteBoolParameter::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_WriteBoolParameter::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_WriteBoolParameter::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_WriteBoolParameter::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_WriteBoolParameter::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_WriteBoolParameter::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_WriteBoolParameter::set_ParameterNumber(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ParameterNumber) = value_int32(v_);
  return true;
}
bool MC_WriteBoolParameter::set_Value(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Value) = value_bool(v_);
  return true;
}
bool MC_WriteBoolParameter::set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Done) = value_bool(v_);
  return true;
}
bool MC_WriteBoolParameter::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_WriteBoolParameter::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_WriteBoolParameter::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_WriteBoolParameter> MC_WriteBoolParameter::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_WriteBoolParameter::get_Axis, &MC_WriteBoolParameter::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_WriteBoolParameter::get_Busy, &MC_WriteBoolParameter::set_Busy }, 
  {"Done", 4, "BOOL", &MC_WriteBoolParameter::get_Done, &MC_WriteBoolParameter::set_Done }, 
  {"Error", 5, "BOOL", &MC_WriteBoolParameter::get_Error, &MC_WriteBoolParameter::set_Error }, 
  {"Value", 5, "BOOL", &MC_WriteBoolParameter::get_Value, &MC_WriteBoolParameter::set_Value }, 
  {"native", 6, "ULINT", &MC_WriteBoolParameter::get_native, &MC_WriteBoolParameter::set_native }, 
  {"ErrorID", 7, "WORD", &MC_WriteBoolParameter::get_ErrorID, &MC_WriteBoolParameter::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_WriteBoolParameter::get_Execute, &MC_WriteBoolParameter::set_Execute }, 
  {"ParameterNumber", 15, "DINT", &MC_WriteBoolParameter::get_ParameterNumber, &MC_WriteBoolParameter::set_ParameterNumber }, 
};
IEC_Property_Range MC_WriteBoolParameter::property_range_list[] = { 
  {0, 3, 4 }, 
  {3, 2, 5 }, 
  {5, 1, 6 }, 
  {6, 2, 7 }, 
  {8, 1, 15 }, 
};

bool MC_WriteBoolParameter::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int32(writer_, "ParameterNumber", ((ParameterNumber)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Value", ((Value)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Done", ((Done)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_WriteBoolParameter::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ParameterNumber", &v_) == RET_OK)
        (ParameterNumber) = value_int32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Value", &v_) == RET_OK)
        (Value) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Done", &v_) == RET_OK)
        (Done) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_WriteBoolParameter::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_WriteBoolParameter::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_WriteParameter::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_WriteParameter::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_WriteParameter::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_WriteParameter::get_ParameterNumber(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int32(v_, ((ParameterNumber)));
  return true;
}
bool MC_WriteParameter::get_Value(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Value)));
  return true;
}
bool MC_WriteParameter::get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Done)));
  return true;
}
bool MC_WriteParameter::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_WriteParameter::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_WriteParameter::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_WriteParameter::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_WriteParameter::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_WriteParameter::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_WriteParameter::set_ParameterNumber(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ParameterNumber) = value_int32(v_);
  return true;
}
bool MC_WriteParameter::set_Value(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Value) = value_double(v_);
  return true;
}
bool MC_WriteParameter::set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Done) = value_bool(v_);
  return true;
}
bool MC_WriteParameter::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_WriteParameter::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_WriteParameter::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_WriteParameter> MC_WriteParameter::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_WriteParameter::get_Axis, &MC_WriteParameter::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_WriteParameter::get_Busy, &MC_WriteParameter::set_Busy }, 
  {"Done", 4, "BOOL", &MC_WriteParameter::get_Done, &MC_WriteParameter::set_Done }, 
  {"Error", 5, "BOOL", &MC_WriteParameter::get_Error, &MC_WriteParameter::set_Error }, 
  {"Value", 5, "LREAL", &MC_WriteParameter::get_Value, &MC_WriteParameter::set_Value }, 
  {"native", 6, "ULINT", &MC_WriteParameter::get_native, &MC_WriteParameter::set_native }, 
  {"ErrorID", 7, "WORD", &MC_WriteParameter::get_ErrorID, &MC_WriteParameter::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_WriteParameter::get_Execute, &MC_WriteParameter::set_Execute }, 
  {"ParameterNumber", 15, "DINT", &MC_WriteParameter::get_ParameterNumber, &MC_WriteParameter::set_ParameterNumber }, 
};
IEC_Property_Range MC_WriteParameter::property_range_list[] = { 
  {0, 3, 4 }, 
  {3, 2, 5 }, 
  {5, 1, 6 }, 
  {6, 2, 7 }, 
  {8, 1, 15 }, 
};

bool MC_WriteParameter::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int32(writer_, "ParameterNumber", ((ParameterNumber)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Value", ((Value)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Done", ((Done)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_WriteParameter::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ParameterNumber", &v_) == RET_OK)
        (ParameterNumber) = value_int32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Value", &v_) == RET_OK)
        (Value) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Done", &v_) == RET_OK)
        (Done) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_WriteParameter::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_WriteParameter::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool ZMC_FollowPosition::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool ZMC_FollowPosition::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_FollowPosition::get_bExecute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bExecute)));
  return true;
}
bool ZMC_FollowPosition::get_fSetPosition(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((fSetPosition)));
  return true;
}
bool ZMC_FollowPosition::get_bBusy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bBusy)));
  return true;
}
bool ZMC_FollowPosition::get_bCommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bCommandAborted)));
  return true;
}
bool ZMC_FollowPosition::get_bError(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bError)));
  return true;
}
bool ZMC_FollowPosition::get_iErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((iErrorID)));
  return true;
}
bool ZMC_FollowPosition::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool ZMC_FollowPosition::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_FollowPosition::set_bExecute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bExecute) = value_bool(v_);
  return true;
}
bool ZMC_FollowPosition::set_fSetPosition(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (fSetPosition) = value_double(v_);
  return true;
}
bool ZMC_FollowPosition::set_bBusy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bBusy) = value_bool(v_);
  return true;
}
bool ZMC_FollowPosition::set_bCommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bCommandAborted) = value_bool(v_);
  return true;
}
bool ZMC_FollowPosition::set_bError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bError) = value_bool(v_);
  return true;
}
bool ZMC_FollowPosition::set_iErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (iErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<ZMC_FollowPosition> ZMC_FollowPosition::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &ZMC_FollowPosition::get_Axis, &ZMC_FollowPosition::set_Axis }, 
  {"bBusy", 5, "BOOL", &ZMC_FollowPosition::get_bBusy, &ZMC_FollowPosition::set_bBusy }, 
  {"bError", 6, "BOOL", &ZMC_FollowPosition::get_bError, &ZMC_FollowPosition::set_bError }, 
  {"native", 6, "ULINT", &ZMC_FollowPosition::get_native, &ZMC_FollowPosition::set_native }, 
  {"bExecute", 8, "BOOL", &ZMC_FollowPosition::get_bExecute, &ZMC_FollowPosition::set_bExecute }, 
  {"iErrorID", 8, "WORD", &ZMC_FollowPosition::get_iErrorID, &ZMC_FollowPosition::set_iErrorID }, 
  {"fSetPosition", 12, "LREAL", &ZMC_FollowPosition::get_fSetPosition, &ZMC_FollowPosition::set_fSetPosition }, 
  {"bCommandAborted", 15, "BOOL", &ZMC_FollowPosition::get_bCommandAborted, &ZMC_FollowPosition::set_bCommandAborted }, 
};
IEC_Property_Range ZMC_FollowPosition::property_range_list[] = { 
  {0, 1, 4 }, 
  {1, 1, 5 }, 
  {2, 2, 6 }, 
  {4, 2, 8 }, 
  {6, 1, 12 }, 
  {7, 1, 15 }, 
};

bool ZMC_FollowPosition::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bExecute", ((bExecute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "fSetPosition", ((fSetPosition)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bBusy", ((bBusy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bCommandAborted", ((bCommandAborted)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bError", ((bError)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "iErrorID", ((iErrorID)));
  }
  return true;
}

bool ZMC_FollowPosition::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bExecute", &v_) == RET_OK)
        (bExecute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "fSetPosition", &v_) == RET_OK)
        (fSetPosition) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bBusy", &v_) == RET_OK)
        (bBusy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bCommandAborted", &v_) == RET_OK)
        (bCommandAborted) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bError", &v_) == RET_OK)
        (bError) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "iErrorID", &v_) == RET_OK)
        (iErrorID) = value_uint16(&v_);
  }
  return true;
}

bool ZMC_FollowPosition::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool ZMC_FollowPosition::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool ZMC_GetTappetValue::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool ZMC_GetTappetValue::get_Tappets(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Tappets);
    return true;
  } else if (*name_ != '^' || Tappets == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Tappets->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_GetTappetValue::get_iID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((iID)));
  return true;
}
bool ZMC_GetTappetValue::get_bInitValue(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bInitValue)));
  return true;
}
bool ZMC_GetTappetValue::get_bSetInitValueAtReset(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bSetInitValueAtReset)));
  return true;
}
bool ZMC_GetTappetValue::get_bTappet(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bTappet)));
  return true;
}
bool ZMC_GetTappetValue::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool ZMC_GetTappetValue::set_Tappets(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Tappets = static_cast<ZMC_TappetData* >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Tappets == NULL) { return false; }

  return Tappets->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_GetTappetValue::set_iID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (iID) = value_int16(v_);
  return true;
}
bool ZMC_GetTappetValue::set_bInitValue(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bInitValue) = value_bool(v_);
  return true;
}
bool ZMC_GetTappetValue::set_bSetInitValueAtReset(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bSetInitValueAtReset) = value_bool(v_);
  return true;
}
bool ZMC_GetTappetValue::set_bTappet(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bTappet) = value_bool(v_);
  return true;
}

IEC_Property<ZMC_GetTappetValue> ZMC_GetTappetValue::property_list[] = { 
  {"iID", 3, "INT", &ZMC_GetTappetValue::get_iID, &ZMC_GetTappetValue::set_iID }, 
  {"native", 6, "ULINT", &ZMC_GetTappetValue::get_native, &ZMC_GetTappetValue::set_native }, 
  {"Tappets", 7, "POINTER TO ZMC_TappetData", &ZMC_GetTappetValue::get_Tappets, &ZMC_GetTappetValue::set_Tappets }, 
  {"bTappet", 7, "BOOL", &ZMC_GetTappetValue::get_bTappet, &ZMC_GetTappetValue::set_bTappet }, 
  {"bInitValue", 10, "BOOL", &ZMC_GetTappetValue::get_bInitValue, &ZMC_GetTappetValue::set_bInitValue }, 
  {"bSetInitValueAtReset", 20, "BOOL", &ZMC_GetTappetValue::get_bSetInitValueAtReset, &ZMC_GetTappetValue::set_bSetInitValueAtReset }, 
};
IEC_Property_Range ZMC_GetTappetValue::property_range_list[] = { 
  {0, 1, 3 }, 
  {1, 1, 6 }, 
  {2, 2, 7 }, 
  {4, 1, 10 }, 
  {5, 1, 20 }, 
};

bool ZMC_GetTappetValue::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Tappets != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Tappets");
      Tappets->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int16(writer_, "iID", ((iID)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bInitValue", ((bInitValue)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bSetInitValueAtReset", ((bSetInitValueAtReset)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bTappet", ((bTappet)));
  }
  return true;
}

bool ZMC_GetTappetValue::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Tappets != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Tappets");
      if (sub != nullptr) Tappets->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "iID", &v_) == RET_OK)
        (iID) = value_int16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bInitValue", &v_) == RET_OK)
        (bInitValue) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bSetInitValueAtReset", &v_) == RET_OK)
        (bSetInitValueAtReset) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bTappet", &v_) == RET_OK)
        (bTappet) = value_bool(&v_);
  }
  return true;
}

bool ZMC_GetTappetValue::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool ZMC_GetTappetValue::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool ZMC_ReadCAM::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool ZMC_ReadCAM::get_bExecute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bExecute)));
  return true;
}
bool ZMC_ReadCAM::get_sFileName(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_str(v_, ((sFileName)).get());
  return true;
}
bool ZMC_ReadCAM::get_bDone(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bDone)));
  return true;
}
bool ZMC_ReadCAM::get_bBusy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bBusy)));
  return true;
}
bool ZMC_ReadCAM::get_bError(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bError)));
  return true;
}
bool ZMC_ReadCAM::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool ZMC_ReadCAM::get_CAM(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, CAM);
    return true;
  } else if (*name_ != '^' || CAM == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return CAM->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_ReadCAM::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool ZMC_ReadCAM::set_bExecute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bExecute) = value_bool(v_);
  return true;
}
bool ZMC_ReadCAM::set_sFileName(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (sFileName) = value_str(v_);
  return true;
}
bool ZMC_ReadCAM::set_bDone(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bDone) = value_bool(v_);
  return true;
}
bool ZMC_ReadCAM::set_bBusy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bBusy) = value_bool(v_);
  return true;
}
bool ZMC_ReadCAM::set_bError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bError) = value_bool(v_);
  return true;
}
bool ZMC_ReadCAM::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}
bool ZMC_ReadCAM::set_CAM(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    CAM = static_cast<MC_CAM_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || CAM == NULL) { return false; }

  return CAM->set_(tk_str_skip_object_prefix(name_), v_, obj);
}

IEC_Property<ZMC_ReadCAM> ZMC_ReadCAM::property_list[] = { 
  {"CAM", 3, "POINTER TO ZMC_CAM_TABLE", &ZMC_ReadCAM::get_CAM, &ZMC_ReadCAM::set_CAM }, 
  {"bBusy", 5, "BOOL", &ZMC_ReadCAM::get_bBusy, &ZMC_ReadCAM::set_bBusy }, 
  {"bDone", 5, "BOOL", &ZMC_ReadCAM::get_bDone, &ZMC_ReadCAM::set_bDone }, 
  {"bError", 6, "BOOL", &ZMC_ReadCAM::get_bError, &ZMC_ReadCAM::set_bError }, 
  {"native", 6, "ULINT", &ZMC_ReadCAM::get_native, &ZMC_ReadCAM::set_native }, 
  {"ErrorID", 7, "WORD", &ZMC_ReadCAM::get_ErrorID, &ZMC_ReadCAM::set_ErrorID }, 
  {"bExecute", 8, "BOOL", &ZMC_ReadCAM::get_bExecute, &ZMC_ReadCAM::set_bExecute }, 
  {"sFileName", 9, "STRING", &ZMC_ReadCAM::get_sFileName, &ZMC_ReadCAM::set_sFileName }, 
};
IEC_Property_Range ZMC_ReadCAM::property_range_list[] = { 
  {0, 1, 3 }, 
  {1, 2, 5 }, 
  {3, 2, 6 }, 
  {5, 1, 7 }, 
  {6, 1, 8 }, 
  {7, 1, 9 }, 
};

bool ZMC_ReadCAM::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bExecute", ((bExecute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_str(writer_, "sFileName", ((sFileName)).get());
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bDone", ((bDone)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bBusy", ((bBusy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bError", ((bError)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (CAM != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "CAM");
      CAM->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  return true;
}

bool ZMC_ReadCAM::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bExecute", &v_) == RET_OK)
        (bExecute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "sFileName", &v_) == RET_OK)
        (sFileName) = value_str(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bDone", &v_) == RET_OK)
        (bDone) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bBusy", &v_) == RET_OK)
        (bBusy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bError", &v_) == RET_OK)
        (bError) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (CAM != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "CAM");
      if (sub != nullptr) CAM->load_(sub, type_, nullptr);
  }
  return true;
}

bool ZMC_ReadCAM::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool ZMC_ReadCAM::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool ZMC_WriteCAM::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool ZMC_WriteCAM::get_CAM(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, CAM);
    return true;
  } else if (*name_ != '^' || CAM == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return CAM->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_WriteCAM::get_bExecute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bExecute)));
  return true;
}
bool ZMC_WriteCAM::get_sFileName(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_str(v_, ((sFileName)).get());
  return true;
}
bool ZMC_WriteCAM::get_bDone(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bDone)));
  return true;
}
bool ZMC_WriteCAM::get_bBusy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bBusy)));
  return true;
}
bool ZMC_WriteCAM::get_bError(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bError)));
  return true;
}
bool ZMC_WriteCAM::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool ZMC_WriteCAM::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool ZMC_WriteCAM::set_CAM(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    CAM = static_cast<MC_CAM_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || CAM == NULL) { return false; }

  return CAM->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_WriteCAM::set_bExecute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bExecute) = value_bool(v_);
  return true;
}
bool ZMC_WriteCAM::set_sFileName(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (sFileName) = value_str(v_);
  return true;
}
bool ZMC_WriteCAM::set_bDone(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bDone) = value_bool(v_);
  return true;
}
bool ZMC_WriteCAM::set_bBusy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bBusy) = value_bool(v_);
  return true;
}
bool ZMC_WriteCAM::set_bError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bError) = value_bool(v_);
  return true;
}
bool ZMC_WriteCAM::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<ZMC_WriteCAM> ZMC_WriteCAM::property_list[] = { 
  {"CAM", 3, "POINTER TO ZMC_CAM_TABLE", &ZMC_WriteCAM::get_CAM, &ZMC_WriteCAM::set_CAM }, 
  {"bBusy", 5, "BOOL", &ZMC_WriteCAM::get_bBusy, &ZMC_WriteCAM::set_bBusy }, 
  {"bDone", 5, "BOOL", &ZMC_WriteCAM::get_bDone, &ZMC_WriteCAM::set_bDone }, 
  {"bError", 6, "BOOL", &ZMC_WriteCAM::get_bError, &ZMC_WriteCAM::set_bError }, 
  {"native", 6, "ULINT", &ZMC_WriteCAM::get_native, &ZMC_WriteCAM::set_native }, 
  {"ErrorID", 7, "WORD", &ZMC_WriteCAM::get_ErrorID, &ZMC_WriteCAM::set_ErrorID }, 
  {"bExecute", 8, "BOOL", &ZMC_WriteCAM::get_bExecute, &ZMC_WriteCAM::set_bExecute }, 
  {"sFileName", 9, "STRING", &ZMC_WriteCAM::get_sFileName, &ZMC_WriteCAM::set_sFileName }, 
};
IEC_Property_Range ZMC_WriteCAM::property_range_list[] = { 
  {0, 1, 3 }, 
  {1, 2, 5 }, 
  {3, 2, 6 }, 
  {5, 1, 7 }, 
  {6, 1, 8 }, 
  {7, 1, 9 }, 
};

bool ZMC_WriteCAM::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (CAM != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "CAM");
      CAM->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bExecute", ((bExecute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_str(writer_, "sFileName", ((sFileName)).get());
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bDone", ((bDone)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bBusy", ((bBusy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bError", ((bError)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool ZMC_WriteCAM::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (CAM != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "CAM");
      if (sub != nullptr) CAM->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bExecute", &v_) == RET_OK)
        (bExecute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "sFileName", &v_) == RET_OK)
        (sFileName) = value_str(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bDone", &v_) == RET_OK)
        (bDone) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bBusy", &v_) == RET_OK)
        (bBusy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bError", &v_) == RET_OK)
        (bError) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool ZMC_WriteCAM::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool ZMC_WriteCAM::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_ReadActualDriveValues::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_ReadActualDriveValues::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_ReadActualDriveValues::get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Enable)));
  return true;
}
bool MC_ReadActualDriveValues::get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Valid)));
  return true;
}
bool MC_ReadActualDriveValues::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_ReadActualDriveValues::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_ReadActualDriveValues::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_ReadActualDriveValues::get_Position(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int32(v_, ((Position)));
  return true;
}
bool MC_ReadActualDriveValues::get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int32(v_, ((Velocity)));
  return true;
}
bool MC_ReadActualDriveValues::get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int32(v_, ((Acceleration)));
  return true;
}
bool MC_ReadActualDriveValues::get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int32(v_, ((Jerk)));
  return true;
}
bool MC_ReadActualDriveValues::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_ReadActualDriveValues::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_ReadActualDriveValues::set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Enable) = value_bool(v_);
  return true;
}
bool MC_ReadActualDriveValues::set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Valid) = value_bool(v_);
  return true;
}
bool MC_ReadActualDriveValues::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_ReadActualDriveValues::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_ReadActualDriveValues::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}
bool MC_ReadActualDriveValues::set_Position(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Position) = value_int32(v_);
  return true;
}
bool MC_ReadActualDriveValues::set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Velocity) = value_int32(v_);
  return true;
}
bool MC_ReadActualDriveValues::set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Acceleration) = value_int32(v_);
  return true;
}
bool MC_ReadActualDriveValues::set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Jerk) = value_int32(v_);
  return true;
}

IEC_Property<MC_ReadActualDriveValues> MC_ReadActualDriveValues::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_ReadActualDriveValues::get_Axis, &MC_ReadActualDriveValues::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_ReadActualDriveValues::get_Busy, &MC_ReadActualDriveValues::set_Busy }, 
  {"Jerk", 4, "DINT", &MC_ReadActualDriveValues::get_Jerk, &MC_ReadActualDriveValues::set_Jerk }, 
  {"Error", 5, "BOOL", &MC_ReadActualDriveValues::get_Error, &MC_ReadActualDriveValues::set_Error }, 
  {"Valid", 5, "BOOL", &MC_ReadActualDriveValues::get_Valid, &MC_ReadActualDriveValues::set_Valid }, 
  {"Enable", 6, "BOOL", &MC_ReadActualDriveValues::get_Enable, &MC_ReadActualDriveValues::set_Enable }, 
  {"native", 6, "ULINT", &MC_ReadActualDriveValues::get_native, &MC_ReadActualDriveValues::set_native }, 
  {"ErrorID", 7, "WORD", &MC_ReadActualDriveValues::get_ErrorID, &MC_ReadActualDriveValues::set_ErrorID }, 
  {"Position", 8, "DINT", &MC_ReadActualDriveValues::get_Position, &MC_ReadActualDriveValues::set_Position }, 
  {"Velocity", 8, "DINT", &MC_ReadActualDriveValues::get_Velocity, &MC_ReadActualDriveValues::set_Velocity }, 
  {"Acceleration", 12, "DINT", &MC_ReadActualDriveValues::get_Acceleration, &MC_ReadActualDriveValues::set_Acceleration }, 
};
IEC_Property_Range MC_ReadActualDriveValues::property_range_list[] = { 
  {0, 3, 4 }, 
  {3, 2, 5 }, 
  {5, 2, 6 }, 
  {7, 1, 7 }, 
  {8, 2, 8 }, 
  {10, 1, 12 }, 
};

bool MC_ReadActualDriveValues::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Enable", ((Enable)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Valid", ((Valid)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int32(writer_, "Position", ((Position)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int32(writer_, "Velocity", ((Velocity)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int32(writer_, "Acceleration", ((Acceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int32(writer_, "Jerk", ((Jerk)));
  }
  return true;
}

bool MC_ReadActualDriveValues::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Enable", &v_) == RET_OK)
        (Enable) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Valid", &v_) == RET_OK)
        (Valid) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Position", &v_) == RET_OK)
        (Position) = value_int32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Velocity", &v_) == RET_OK)
        (Velocity) = value_int32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Acceleration", &v_) == RET_OK)
        (Acceleration) = value_int32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Jerk", &v_) == RET_OK)
        (Jerk) = value_int32(&v_);
  }
  return true;
}

bool MC_ReadActualDriveValues::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_ReadActualDriveValues::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_ReadActualValues::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_ReadActualValues::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_ReadActualValues::get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Enable)));
  return true;
}
bool MC_ReadActualValues::get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Valid)));
  return true;
}
bool MC_ReadActualValues::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_ReadActualValues::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_ReadActualValues::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_ReadActualValues::get_Position(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Position)));
  return true;
}
bool MC_ReadActualValues::get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Velocity)));
  return true;
}
bool MC_ReadActualValues::get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Acceleration)));
  return true;
}
bool MC_ReadActualValues::get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Jerk)));
  return true;
}
bool MC_ReadActualValues::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_ReadActualValues::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_ReadActualValues::set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Enable) = value_bool(v_);
  return true;
}
bool MC_ReadActualValues::set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Valid) = value_bool(v_);
  return true;
}
bool MC_ReadActualValues::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_ReadActualValues::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_ReadActualValues::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}
bool MC_ReadActualValues::set_Position(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Position) = value_double(v_);
  return true;
}
bool MC_ReadActualValues::set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Velocity) = value_double(v_);
  return true;
}
bool MC_ReadActualValues::set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Acceleration) = value_double(v_);
  return true;
}
bool MC_ReadActualValues::set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Jerk) = value_double(v_);
  return true;
}

IEC_Property<MC_ReadActualValues> MC_ReadActualValues::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_ReadActualValues::get_Axis, &MC_ReadActualValues::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_ReadActualValues::get_Busy, &MC_ReadActualValues::set_Busy }, 
  {"Jerk", 4, "LREAL", &MC_ReadActualValues::get_Jerk, &MC_ReadActualValues::set_Jerk }, 
  {"Error", 5, "BOOL", &MC_ReadActualValues::get_Error, &MC_ReadActualValues::set_Error }, 
  {"Valid", 5, "BOOL", &MC_ReadActualValues::get_Valid, &MC_ReadActualValues::set_Valid }, 
  {"Enable", 6, "BOOL", &MC_ReadActualValues::get_Enable, &MC_ReadActualValues::set_Enable }, 
  {"native", 6, "ULINT", &MC_ReadActualValues::get_native, &MC_ReadActualValues::set_native }, 
  {"ErrorID", 7, "WORD", &MC_ReadActualValues::get_ErrorID, &MC_ReadActualValues::set_ErrorID }, 
  {"Position", 8, "LREAL", &MC_ReadActualValues::get_Position, &MC_ReadActualValues::set_Position }, 
  {"Velocity", 8, "LREAL", &MC_ReadActualValues::get_Velocity, &MC_ReadActualValues::set_Velocity }, 
  {"Acceleration", 12, "LREAL", &MC_ReadActualValues::get_Acceleration, &MC_ReadActualValues::set_Acceleration }, 
};
IEC_Property_Range MC_ReadActualValues::property_range_list[] = { 
  {0, 3, 4 }, 
  {3, 2, 5 }, 
  {5, 2, 6 }, 
  {7, 1, 7 }, 
  {8, 2, 8 }, 
  {10, 1, 12 }, 
};

bool MC_ReadActualValues::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Enable", ((Enable)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Valid", ((Valid)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Position", ((Position)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Velocity", ((Velocity)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Acceleration", ((Acceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Jerk", ((Jerk)));
  }
  return true;
}

bool MC_ReadActualValues::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Enable", &v_) == RET_OK)
        (Enable) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Valid", &v_) == RET_OK)
        (Valid) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Position", &v_) == RET_OK)
        (Position) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Velocity", &v_) == RET_OK)
        (Velocity) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Acceleration", &v_) == RET_OK)
        (Acceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Jerk", &v_) == RET_OK)
        (Jerk) = value_double(&v_);
  }
  return true;
}

bool MC_ReadActualValues::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_ReadActualValues::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_ReadSetDriveValues::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_ReadSetDriveValues::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_ReadSetDriveValues::get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Enable)));
  return true;
}
bool MC_ReadSetDriveValues::get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Valid)));
  return true;
}
bool MC_ReadSetDriveValues::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_ReadSetDriveValues::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_ReadSetDriveValues::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_ReadSetDriveValues::get_Position(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int32(v_, ((Position)));
  return true;
}
bool MC_ReadSetDriveValues::get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int32(v_, ((Velocity)));
  return true;
}
bool MC_ReadSetDriveValues::get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int32(v_, ((Acceleration)));
  return true;
}
bool MC_ReadSetDriveValues::get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int32(v_, ((Jerk)));
  return true;
}
bool MC_ReadSetDriveValues::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_ReadSetDriveValues::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_ReadSetDriveValues::set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Enable) = value_bool(v_);
  return true;
}
bool MC_ReadSetDriveValues::set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Valid) = value_bool(v_);
  return true;
}
bool MC_ReadSetDriveValues::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_ReadSetDriveValues::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_ReadSetDriveValues::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}
bool MC_ReadSetDriveValues::set_Position(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Position) = value_int32(v_);
  return true;
}
bool MC_ReadSetDriveValues::set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Velocity) = value_int32(v_);
  return true;
}
bool MC_ReadSetDriveValues::set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Acceleration) = value_int32(v_);
  return true;
}
bool MC_ReadSetDriveValues::set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Jerk) = value_int32(v_);
  return true;
}

IEC_Property<MC_ReadSetDriveValues> MC_ReadSetDriveValues::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_ReadSetDriveValues::get_Axis, &MC_ReadSetDriveValues::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_ReadSetDriveValues::get_Busy, &MC_ReadSetDriveValues::set_Busy }, 
  {"Jerk", 4, "DINT", &MC_ReadSetDriveValues::get_Jerk, &MC_ReadSetDriveValues::set_Jerk }, 
  {"Error", 5, "BOOL", &MC_ReadSetDriveValues::get_Error, &MC_ReadSetDriveValues::set_Error }, 
  {"Valid", 5, "BOOL", &MC_ReadSetDriveValues::get_Valid, &MC_ReadSetDriveValues::set_Valid }, 
  {"Enable", 6, "BOOL", &MC_ReadSetDriveValues::get_Enable, &MC_ReadSetDriveValues::set_Enable }, 
  {"native", 6, "ULINT", &MC_ReadSetDriveValues::get_native, &MC_ReadSetDriveValues::set_native }, 
  {"ErrorID", 7, "WORD", &MC_ReadSetDriveValues::get_ErrorID, &MC_ReadSetDriveValues::set_ErrorID }, 
  {"Position", 8, "DINT", &MC_ReadSetDriveValues::get_Position, &MC_ReadSetDriveValues::set_Position }, 
  {"Velocity", 8, "DINT", &MC_ReadSetDriveValues::get_Velocity, &MC_ReadSetDriveValues::set_Velocity }, 
  {"Acceleration", 12, "DINT", &MC_ReadSetDriveValues::get_Acceleration, &MC_ReadSetDriveValues::set_Acceleration }, 
};
IEC_Property_Range MC_ReadSetDriveValues::property_range_list[] = { 
  {0, 3, 4 }, 
  {3, 2, 5 }, 
  {5, 2, 6 }, 
  {7, 1, 7 }, 
  {8, 2, 8 }, 
  {10, 1, 12 }, 
};

bool MC_ReadSetDriveValues::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Enable", ((Enable)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Valid", ((Valid)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int32(writer_, "Position", ((Position)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int32(writer_, "Velocity", ((Velocity)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int32(writer_, "Acceleration", ((Acceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int32(writer_, "Jerk", ((Jerk)));
  }
  return true;
}

bool MC_ReadSetDriveValues::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Enable", &v_) == RET_OK)
        (Enable) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Valid", &v_) == RET_OK)
        (Valid) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Position", &v_) == RET_OK)
        (Position) = value_int32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Velocity", &v_) == RET_OK)
        (Velocity) = value_int32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Acceleration", &v_) == RET_OK)
        (Acceleration) = value_int32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Jerk", &v_) == RET_OK)
        (Jerk) = value_int32(&v_);
  }
  return true;
}

bool MC_ReadSetDriveValues::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_ReadSetDriveValues::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_ReadSetValues::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_ReadSetValues::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_ReadSetValues::get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Enable)));
  return true;
}
bool MC_ReadSetValues::get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Valid)));
  return true;
}
bool MC_ReadSetValues::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_ReadSetValues::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_ReadSetValues::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_ReadSetValues::get_Position(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Position)));
  return true;
}
bool MC_ReadSetValues::get_Velocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Velocity)));
  return true;
}
bool MC_ReadSetValues::get_Acceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Acceleration)));
  return true;
}
bool MC_ReadSetValues::get_Jerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((Jerk)));
  return true;
}
bool MC_ReadSetValues::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_ReadSetValues::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_ReadSetValues::set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Enable) = value_bool(v_);
  return true;
}
bool MC_ReadSetValues::set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Valid) = value_bool(v_);
  return true;
}
bool MC_ReadSetValues::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_ReadSetValues::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_ReadSetValues::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}
bool MC_ReadSetValues::set_Position(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Position) = value_double(v_);
  return true;
}
bool MC_ReadSetValues::set_Velocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Velocity) = value_double(v_);
  return true;
}
bool MC_ReadSetValues::set_Acceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Acceleration) = value_double(v_);
  return true;
}
bool MC_ReadSetValues::set_Jerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Jerk) = value_double(v_);
  return true;
}

IEC_Property<MC_ReadSetValues> MC_ReadSetValues::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_ReadSetValues::get_Axis, &MC_ReadSetValues::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_ReadSetValues::get_Busy, &MC_ReadSetValues::set_Busy }, 
  {"Jerk", 4, "LREAL", &MC_ReadSetValues::get_Jerk, &MC_ReadSetValues::set_Jerk }, 
  {"Error", 5, "BOOL", &MC_ReadSetValues::get_Error, &MC_ReadSetValues::set_Error }, 
  {"Valid", 5, "BOOL", &MC_ReadSetValues::get_Valid, &MC_ReadSetValues::set_Valid }, 
  {"Enable", 6, "BOOL", &MC_ReadSetValues::get_Enable, &MC_ReadSetValues::set_Enable }, 
  {"native", 6, "ULINT", &MC_ReadSetValues::get_native, &MC_ReadSetValues::set_native }, 
  {"ErrorID", 7, "WORD", &MC_ReadSetValues::get_ErrorID, &MC_ReadSetValues::set_ErrorID }, 
  {"Position", 8, "LREAL", &MC_ReadSetValues::get_Position, &MC_ReadSetValues::set_Position }, 
  {"Velocity", 8, "LREAL", &MC_ReadSetValues::get_Velocity, &MC_ReadSetValues::set_Velocity }, 
  {"Acceleration", 12, "LREAL", &MC_ReadSetValues::get_Acceleration, &MC_ReadSetValues::set_Acceleration }, 
};
IEC_Property_Range MC_ReadSetValues::property_range_list[] = { 
  {0, 3, 4 }, 
  {3, 2, 5 }, 
  {5, 2, 6 }, 
  {7, 1, 7 }, 
  {8, 2, 8 }, 
  {10, 1, 12 }, 
};

bool MC_ReadSetValues::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Enable", ((Enable)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Valid", ((Valid)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Position", ((Position)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Velocity", ((Velocity)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Acceleration", ((Acceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "Jerk", ((Jerk)));
  }
  return true;
}

bool MC_ReadSetValues::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Enable", &v_) == RET_OK)
        (Enable) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Valid", &v_) == RET_OK)
        (Valid) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Position", &v_) == RET_OK)
        (Position) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Velocity", &v_) == RET_OK)
        (Velocity) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Acceleration", &v_) == RET_OK)
        (Acceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Jerk", &v_) == RET_OK)
        (Jerk) = value_double(&v_);
  }
  return true;
}

bool MC_ReadSetValues::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_ReadSetValues::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool ZMC_ChangeGearingRatio::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool ZMC_ChangeGearingRatio::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_ChangeGearingRatio::get_bExecute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bExecute)));
  return true;
}
bool ZMC_ChangeGearingRatio::get_dwRatioTechUnitsDenom(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint32(v_, ((dwRatioTechUnitsDenom)));
  return true;
}
bool ZMC_ChangeGearingRatio::get_iRatioTechUnitsNum(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int32(v_, ((iRatioTechUnitsNum)));
  return true;
}
bool ZMC_ChangeGearingRatio::get_fPositionPeriod(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((fPositionPeriod)));
  return true;
}
bool ZMC_ChangeGearingRatio::get_iMovementType(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((iMovementType)));
  return true;
}
bool ZMC_ChangeGearingRatio::get_bDone(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bDone)));
  return true;
}
bool ZMC_ChangeGearingRatio::get_bBusy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bBusy)));
  return true;
}
bool ZMC_ChangeGearingRatio::get_bError(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bError)));
  return true;
}
bool ZMC_ChangeGearingRatio::get_nErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((nErrorID)));
  return true;
}
bool ZMC_ChangeGearingRatio::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool ZMC_ChangeGearingRatio::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_ChangeGearingRatio::set_bExecute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bExecute) = value_bool(v_);
  return true;
}
bool ZMC_ChangeGearingRatio::set_dwRatioTechUnitsDenom(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (dwRatioTechUnitsDenom) = value_uint32(v_);
  return true;
}
bool ZMC_ChangeGearingRatio::set_iRatioTechUnitsNum(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (iRatioTechUnitsNum) = value_int32(v_);
  return true;
}
bool ZMC_ChangeGearingRatio::set_fPositionPeriod(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (fPositionPeriod) = value_double(v_);
  return true;
}
bool ZMC_ChangeGearingRatio::set_iMovementType(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (iMovementType) = value_int16(v_);
  return true;
}
bool ZMC_ChangeGearingRatio::set_bDone(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bDone) = value_bool(v_);
  return true;
}
bool ZMC_ChangeGearingRatio::set_bBusy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bBusy) = value_bool(v_);
  return true;
}
bool ZMC_ChangeGearingRatio::set_bError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bError) = value_bool(v_);
  return true;
}
bool ZMC_ChangeGearingRatio::set_nErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (nErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<ZMC_ChangeGearingRatio> ZMC_ChangeGearingRatio::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &ZMC_ChangeGearingRatio::get_Axis, &ZMC_ChangeGearingRatio::set_Axis }, 
  {"bBusy", 5, "BOOL", &ZMC_ChangeGearingRatio::get_bBusy, &ZMC_ChangeGearingRatio::set_bBusy }, 
  {"bDone", 5, "BOOL", &ZMC_ChangeGearingRatio::get_bDone, &ZMC_ChangeGearingRatio::set_bDone }, 
  {"bError", 6, "BOOL", &ZMC_ChangeGearingRatio::get_bError, &ZMC_ChangeGearingRatio::set_bError }, 
  {"native", 6, "ULINT", &ZMC_ChangeGearingRatio::get_native, &ZMC_ChangeGearingRatio::set_native }, 
  {"bExecute", 8, "BOOL", &ZMC_ChangeGearingRatio::get_bExecute, &ZMC_ChangeGearingRatio::set_bExecute }, 
  {"nErrorID", 8, "WORD", &ZMC_ChangeGearingRatio::get_nErrorID, &ZMC_ChangeGearingRatio::set_nErrorID }, 
  {"iMovementType", 13, "INT", &ZMC_ChangeGearingRatio::get_iMovementType, &ZMC_ChangeGearingRatio::set_iMovementType }, 
  {"fPositionPeriod", 15, "LREAL", &ZMC_ChangeGearingRatio::get_fPositionPeriod, &ZMC_ChangeGearingRatio::set_fPositionPeriod }, 
  {"iRatioTechUnitsNum", 18, "DINT", &ZMC_ChangeGearingRatio::get_iRatioTechUnitsNum, &ZMC_ChangeGearingRatio::set_iRatioTechUnitsNum }, 
  {"dwRatioTechUnitsDenom", 21, "UDINT", &ZMC_ChangeGearingRatio::get_dwRatioTechUnitsDenom, &ZMC_ChangeGearingRatio::set_dwRatioTechUnitsDenom }, 
};
IEC_Property_Range ZMC_ChangeGearingRatio::property_range_list[] = { 
  {0, 1, 4 }, 
  {1, 2, 5 }, 
  {3, 2, 6 }, 
  {5, 2, 8 }, 
  {7, 1, 13 }, 
  {8, 1, 15 }, 
  {9, 1, 18 }, 
  {10, 1, 21 }, 
};

bool ZMC_ChangeGearingRatio::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bExecute", ((bExecute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint32(writer_, "dwRatioTechUnitsDenom", ((dwRatioTechUnitsDenom)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int32(writer_, "iRatioTechUnitsNum", ((iRatioTechUnitsNum)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "fPositionPeriod", ((fPositionPeriod)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int16(writer_, "iMovementType", ((iMovementType)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bDone", ((bDone)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bBusy", ((bBusy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bError", ((bError)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "nErrorID", ((nErrorID)));
  }
  return true;
}

bool ZMC_ChangeGearingRatio::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bExecute", &v_) == RET_OK)
        (bExecute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "dwRatioTechUnitsDenom", &v_) == RET_OK)
        (dwRatioTechUnitsDenom) = value_uint32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "iRatioTechUnitsNum", &v_) == RET_OK)
        (iRatioTechUnitsNum) = value_int32(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "fPositionPeriod", &v_) == RET_OK)
        (fPositionPeriod) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "iMovementType", &v_) == RET_OK)
        (iMovementType) = value_int16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bDone", &v_) == RET_OK)
        (bDone) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bBusy", &v_) == RET_OK)
        (bBusy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bError", &v_) == RET_OK)
        (bError) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "nErrorID", &v_) == RET_OK)
        (nErrorID) = value_uint16(&v_);
  }
  return true;
}

bool ZMC_ChangeGearingRatio::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool ZMC_ChangeGearingRatio::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool ZMC_CheckLimits::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool ZMC_CheckLimits::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_CheckLimits::get_bEnable(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bEnable)));
  return true;
}
bool ZMC_CheckLimits::get_bCheckVel(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bCheckVel)));
  return true;
}
bool ZMC_CheckLimits::get_bCheckAccDec(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bCheckAccDec)));
  return true;
}
bool ZMC_CheckLimits::get_bBusy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bBusy)));
  return true;
}
bool ZMC_CheckLimits::get_bError(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bError)));
  return true;
}
bool ZMC_CheckLimits::get_iErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((iErrorID)));
  return true;
}
bool ZMC_CheckLimits::get_bLimitsExceeded(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bLimitsExceeded)));
  return true;
}
bool ZMC_CheckLimits::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool ZMC_CheckLimits::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_CheckLimits::set_bEnable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bEnable) = value_bool(v_);
  return true;
}
bool ZMC_CheckLimits::set_bCheckVel(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bCheckVel) = value_bool(v_);
  return true;
}
bool ZMC_CheckLimits::set_bCheckAccDec(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bCheckAccDec) = value_bool(v_);
  return true;
}
bool ZMC_CheckLimits::set_bBusy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bBusy) = value_bool(v_);
  return true;
}
bool ZMC_CheckLimits::set_bError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bError) = value_bool(v_);
  return true;
}
bool ZMC_CheckLimits::set_iErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (iErrorID) = value_uint16(v_);
  return true;
}
bool ZMC_CheckLimits::set_bLimitsExceeded(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bLimitsExceeded) = value_bool(v_);
  return true;
}

IEC_Property<ZMC_CheckLimits> ZMC_CheckLimits::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &ZMC_CheckLimits::get_Axis, &ZMC_CheckLimits::set_Axis }, 
  {"bBusy", 5, "BOOL", &ZMC_CheckLimits::get_bBusy, &ZMC_CheckLimits::set_bBusy }, 
  {"bError", 6, "BOOL", &ZMC_CheckLimits::get_bError, &ZMC_CheckLimits::set_bError }, 
  {"native", 6, "ULINT", &ZMC_CheckLimits::get_native, &ZMC_CheckLimits::set_native }, 
  {"bEnable", 7, "BOOL", &ZMC_CheckLimits::get_bEnable, &ZMC_CheckLimits::set_bEnable }, 
  {"iErrorID", 8, "WORD", &ZMC_CheckLimits::get_iErrorID, &ZMC_CheckLimits::set_iErrorID }, 
  {"bCheckVel", 9, "BOOL", &ZMC_CheckLimits::get_bCheckVel, &ZMC_CheckLimits::set_bCheckVel }, 
  {"bCheckAccDec", 12, "BOOL", &ZMC_CheckLimits::get_bCheckAccDec, &ZMC_CheckLimits::set_bCheckAccDec }, 
  {"bLimitsExceeded", 15, "BOOL", &ZMC_CheckLimits::get_bLimitsExceeded, &ZMC_CheckLimits::set_bLimitsExceeded }, 
};
IEC_Property_Range ZMC_CheckLimits::property_range_list[] = { 
  {0, 1, 4 }, 
  {1, 1, 5 }, 
  {2, 2, 6 }, 
  {4, 1, 7 }, 
  {5, 1, 8 }, 
  {6, 1, 9 }, 
  {7, 1, 12 }, 
  {8, 1, 15 }, 
};

bool ZMC_CheckLimits::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bEnable", ((bEnable)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bCheckVel", ((bCheckVel)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bCheckAccDec", ((bCheckAccDec)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bBusy", ((bBusy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bError", ((bError)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "iErrorID", ((iErrorID)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bLimitsExceeded", ((bLimitsExceeded)));
  }
  return true;
}

bool ZMC_CheckLimits::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bEnable", &v_) == RET_OK)
        (bEnable) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bCheckVel", &v_) == RET_OK)
        (bCheckVel) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bCheckAccDec", &v_) == RET_OK)
        (bCheckAccDec) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bBusy", &v_) == RET_OK)
        (bBusy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bError", &v_) == RET_OK)
        (bError) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "iErrorID", &v_) == RET_OK)
        (iErrorID) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bLimitsExceeded", &v_) == RET_OK)
        (bLimitsExceeded) = value_bool(&v_);
  }
  return true;
}

bool ZMC_CheckLimits::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool ZMC_CheckLimits::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool ZMC_ControlAxisByPos::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool ZMC_ControlAxisByPos::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_ControlAxisByPos::get_iStatus(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((iStatus)));
  return true;
}
bool ZMC_ControlAxisByPos::get_bEnable(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bEnable)));
  return true;
}
bool ZMC_ControlAxisByPos::get_bAvoidGaps(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bAvoidGaps)));
  return true;
}
bool ZMC_ControlAxisByPos::get_fSetPosition(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((fSetPosition)));
  return true;
}
bool ZMC_ControlAxisByPos::get_fGapVelocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((fGapVelocity)));
  return true;
}
bool ZMC_ControlAxisByPos::get_fGapAcceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((fGapAcceleration)));
  return true;
}
bool ZMC_ControlAxisByPos::get_fGapDeceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((fGapDeceleration)));
  return true;
}
bool ZMC_ControlAxisByPos::get_fGapJerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((fGapJerk)));
  return true;
}
bool ZMC_ControlAxisByPos::get_bBusy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bBusy)));
  return true;
}
bool ZMC_ControlAxisByPos::get_bCommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bCommandAborted)));
  return true;
}
bool ZMC_ControlAxisByPos::get_bError(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bError)));
  return true;
}
bool ZMC_ControlAxisByPos::get_iErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((iErrorID)));
  return true;
}
bool ZMC_ControlAxisByPos::get_bStopIpo(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bStopIpo)));
  return true;
}
bool ZMC_ControlAxisByPos::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool ZMC_ControlAxisByPos::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_ControlAxisByPos::set_iStatus(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (iStatus) = value_int16(v_);
  return true;
}
bool ZMC_ControlAxisByPos::set_bEnable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bEnable) = value_bool(v_);
  return true;
}
bool ZMC_ControlAxisByPos::set_bAvoidGaps(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bAvoidGaps) = value_bool(v_);
  return true;
}
bool ZMC_ControlAxisByPos::set_fSetPosition(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (fSetPosition) = value_double(v_);
  return true;
}
bool ZMC_ControlAxisByPos::set_fGapVelocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (fGapVelocity) = value_double(v_);
  return true;
}
bool ZMC_ControlAxisByPos::set_fGapAcceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (fGapAcceleration) = value_double(v_);
  return true;
}
bool ZMC_ControlAxisByPos::set_fGapDeceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (fGapDeceleration) = value_double(v_);
  return true;
}
bool ZMC_ControlAxisByPos::set_fGapJerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (fGapJerk) = value_double(v_);
  return true;
}
bool ZMC_ControlAxisByPos::set_bBusy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bBusy) = value_bool(v_);
  return true;
}
bool ZMC_ControlAxisByPos::set_bCommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bCommandAborted) = value_bool(v_);
  return true;
}
bool ZMC_ControlAxisByPos::set_bError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bError) = value_bool(v_);
  return true;
}
bool ZMC_ControlAxisByPos::set_iErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (iErrorID) = value_int16(v_);
  return true;
}
bool ZMC_ControlAxisByPos::set_bStopIpo(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bStopIpo) = value_bool(v_);
  return true;
}

IEC_Property<ZMC_ControlAxisByPos> ZMC_ControlAxisByPos::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &ZMC_ControlAxisByPos::get_Axis, &ZMC_ControlAxisByPos::set_Axis }, 
  {"bBusy", 5, "BOOL", &ZMC_ControlAxisByPos::get_bBusy, &ZMC_ControlAxisByPos::set_bBusy }, 
  {"bError", 6, "BOOL", &ZMC_ControlAxisByPos::get_bError, &ZMC_ControlAxisByPos::set_bError }, 
  {"native", 6, "ULINT", &ZMC_ControlAxisByPos::get_native, &ZMC_ControlAxisByPos::set_native }, 
  {"bEnable", 7, "BOOL", &ZMC_ControlAxisByPos::get_bEnable, &ZMC_ControlAxisByPos::set_bEnable }, 
  {"iStatus", 7, "INT", &ZMC_ControlAxisByPos::get_iStatus, &ZMC_ControlAxisByPos::set_iStatus }, 
  {"bStopIpo", 8, "BOOL", &ZMC_ControlAxisByPos::get_bStopIpo, &ZMC_ControlAxisByPos::set_bStopIpo }, 
  {"fGapJerk", 8, "LREAL", &ZMC_ControlAxisByPos::get_fGapJerk, &ZMC_ControlAxisByPos::set_fGapJerk }, 
  {"iErrorID", 8, "INT", &ZMC_ControlAxisByPos::get_iErrorID, &ZMC_ControlAxisByPos::set_iErrorID }, 
  {"bAvoidGaps", 10, "BOOL", &ZMC_ControlAxisByPos::get_bAvoidGaps, &ZMC_ControlAxisByPos::set_bAvoidGaps }, 
  {"fGapVelocity", 12, "LREAL", &ZMC_ControlAxisByPos::get_fGapVelocity, &ZMC_ControlAxisByPos::set_fGapVelocity }, 
  {"fSetPosition", 12, "LREAL", &ZMC_ControlAxisByPos::get_fSetPosition, &ZMC_ControlAxisByPos::set_fSetPosition }, 
  {"bCommandAborted", 15, "BOOL", &ZMC_ControlAxisByPos::get_bCommandAborted, &ZMC_ControlAxisByPos::set_bCommandAborted }, 
  {"fGapAcceleration", 16, "LREAL", &ZMC_ControlAxisByPos::get_fGapAcceleration, &ZMC_ControlAxisByPos::set_fGapAcceleration }, 
  {"fGapDeceleration", 16, "LREAL", &ZMC_ControlAxisByPos::get_fGapDeceleration, &ZMC_ControlAxisByPos::set_fGapDeceleration }, 
};
IEC_Property_Range ZMC_ControlAxisByPos::property_range_list[] = { 
  {0, 1, 4 }, 
  {1, 1, 5 }, 
  {2, 2, 6 }, 
  {4, 2, 7 }, 
  {6, 3, 8 }, 
  {9, 1, 10 }, 
  {10, 2, 12 }, 
  {12, 1, 15 }, 
  {13, 2, 16 }, 
};

bool ZMC_ControlAxisByPos::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int16(writer_, "iStatus", ((iStatus)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bEnable", ((bEnable)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bAvoidGaps", ((bAvoidGaps)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "fSetPosition", ((fSetPosition)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "fGapVelocity", ((fGapVelocity)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "fGapAcceleration", ((fGapAcceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "fGapDeceleration", ((fGapDeceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "fGapJerk", ((fGapJerk)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bBusy", ((bBusy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bCommandAborted", ((bCommandAborted)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bError", ((bError)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int16(writer_, "iErrorID", ((iErrorID)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bStopIpo", ((bStopIpo)));
  }
  return true;
}

bool ZMC_ControlAxisByPos::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "iStatus", &v_) == RET_OK)
        (iStatus) = value_int16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bEnable", &v_) == RET_OK)
        (bEnable) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bAvoidGaps", &v_) == RET_OK)
        (bAvoidGaps) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "fSetPosition", &v_) == RET_OK)
        (fSetPosition) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "fGapVelocity", &v_) == RET_OK)
        (fGapVelocity) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "fGapAcceleration", &v_) == RET_OK)
        (fGapAcceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "fGapDeceleration", &v_) == RET_OK)
        (fGapDeceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "fGapJerk", &v_) == RET_OK)
        (fGapJerk) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bBusy", &v_) == RET_OK)
        (bBusy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bCommandAborted", &v_) == RET_OK)
        (bCommandAborted) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bError", &v_) == RET_OK)
        (bError) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "iErrorID", &v_) == RET_OK)
        (iErrorID) = value_int16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bStopIpo", &v_) == RET_OK)
        (bStopIpo) = value_bool(&v_);
  }
  return true;
}

bool ZMC_ControlAxisByPos::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool ZMC_ControlAxisByPos::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool ZMC_ControlAxisByPosVel::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool ZMC_ControlAxisByPosVel::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_ControlAxisByPosVel::get_iStatus(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((iStatus)));
  return true;
}
bool ZMC_ControlAxisByPosVel::get_bEnable(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bEnable)));
  return true;
}
bool ZMC_ControlAxisByPosVel::get_bAvoidGaps(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bAvoidGaps)));
  return true;
}
bool ZMC_ControlAxisByPosVel::get_fSetPosition(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((fSetPosition)));
  return true;
}
bool ZMC_ControlAxisByPosVel::get_fSetVelocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((fSetVelocity)));
  return true;
}
bool ZMC_ControlAxisByPosVel::get_fGapVelocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((fGapVelocity)));
  return true;
}
bool ZMC_ControlAxisByPosVel::get_fGapAcceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((fGapAcceleration)));
  return true;
}
bool ZMC_ControlAxisByPosVel::get_fGapDeceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((fGapDeceleration)));
  return true;
}
bool ZMC_ControlAxisByPosVel::get_fGapJerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((fGapJerk)));
  return true;
}
bool ZMC_ControlAxisByPosVel::get_bBusy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bBusy)));
  return true;
}
bool ZMC_ControlAxisByPosVel::get_bCommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bCommandAborted)));
  return true;
}
bool ZMC_ControlAxisByPosVel::get_bError(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bError)));
  return true;
}
bool ZMC_ControlAxisByPosVel::get_iErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((iErrorID)));
  return true;
}
bool ZMC_ControlAxisByPosVel::get_bStopIpo(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bStopIpo)));
  return true;
}
bool ZMC_ControlAxisByPosVel::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool ZMC_ControlAxisByPosVel::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_ControlAxisByPosVel::set_iStatus(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (iStatus) = value_int16(v_);
  return true;
}
bool ZMC_ControlAxisByPosVel::set_bEnable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bEnable) = value_bool(v_);
  return true;
}
bool ZMC_ControlAxisByPosVel::set_bAvoidGaps(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bAvoidGaps) = value_bool(v_);
  return true;
}
bool ZMC_ControlAxisByPosVel::set_fSetPosition(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (fSetPosition) = value_double(v_);
  return true;
}
bool ZMC_ControlAxisByPosVel::set_fSetVelocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (fSetVelocity) = value_double(v_);
  return true;
}
bool ZMC_ControlAxisByPosVel::set_fGapVelocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (fGapVelocity) = value_double(v_);
  return true;
}
bool ZMC_ControlAxisByPosVel::set_fGapAcceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (fGapAcceleration) = value_double(v_);
  return true;
}
bool ZMC_ControlAxisByPosVel::set_fGapDeceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (fGapDeceleration) = value_double(v_);
  return true;
}
bool ZMC_ControlAxisByPosVel::set_fGapJerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (fGapJerk) = value_double(v_);
  return true;
}
bool ZMC_ControlAxisByPosVel::set_bBusy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bBusy) = value_bool(v_);
  return true;
}
bool ZMC_ControlAxisByPosVel::set_bCommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bCommandAborted) = value_bool(v_);
  return true;
}
bool ZMC_ControlAxisByPosVel::set_bError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bError) = value_bool(v_);
  return true;
}
bool ZMC_ControlAxisByPosVel::set_iErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (iErrorID) = value_int16(v_);
  return true;
}
bool ZMC_ControlAxisByPosVel::set_bStopIpo(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bStopIpo) = value_bool(v_);
  return true;
}

IEC_Property<ZMC_ControlAxisByPosVel> ZMC_ControlAxisByPosVel::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &ZMC_ControlAxisByPosVel::get_Axis, &ZMC_ControlAxisByPosVel::set_Axis }, 
  {"bBusy", 5, "BOOL", &ZMC_ControlAxisByPosVel::get_bBusy, &ZMC_ControlAxisByPosVel::set_bBusy }, 
  {"bError", 6, "BOOL", &ZMC_ControlAxisByPosVel::get_bError, &ZMC_ControlAxisByPosVel::set_bError }, 
  {"native", 6, "ULINT", &ZMC_ControlAxisByPosVel::get_native, &ZMC_ControlAxisByPosVel::set_native }, 
  {"bEnable", 7, "BOOL", &ZMC_ControlAxisByPosVel::get_bEnable, &ZMC_ControlAxisByPosVel::set_bEnable }, 
  {"iStatus", 7, "INT", &ZMC_ControlAxisByPosVel::get_iStatus, &ZMC_ControlAxisByPosVel::set_iStatus }, 
  {"bStopIpo", 8, "BOOL", &ZMC_ControlAxisByPosVel::get_bStopIpo, &ZMC_ControlAxisByPosVel::set_bStopIpo }, 
  {"fGapJerk", 8, "LREAL", &ZMC_ControlAxisByPosVel::get_fGapJerk, &ZMC_ControlAxisByPosVel::set_fGapJerk }, 
  {"iErrorID", 8, "INT", &ZMC_ControlAxisByPosVel::get_iErrorID, &ZMC_ControlAxisByPosVel::set_iErrorID }, 
  {"bAvoidGaps", 10, "BOOL", &ZMC_ControlAxisByPosVel::get_bAvoidGaps, &ZMC_ControlAxisByPosVel::set_bAvoidGaps }, 
  {"fGapVelocity", 12, "LREAL", &ZMC_ControlAxisByPosVel::get_fGapVelocity, &ZMC_ControlAxisByPosVel::set_fGapVelocity }, 
  {"fSetPosition", 12, "LREAL", &ZMC_ControlAxisByPosVel::get_fSetPosition, &ZMC_ControlAxisByPosVel::set_fSetPosition }, 
  {"fSetVelocity", 12, "LREAL", &ZMC_ControlAxisByPosVel::get_fSetVelocity, &ZMC_ControlAxisByPosVel::set_fSetVelocity }, 
  {"bCommandAborted", 15, "BOOL", &ZMC_ControlAxisByPosVel::get_bCommandAborted, &ZMC_ControlAxisByPosVel::set_bCommandAborted }, 
  {"fGapAcceleration", 16, "LREAL", &ZMC_ControlAxisByPosVel::get_fGapAcceleration, &ZMC_ControlAxisByPosVel::set_fGapAcceleration }, 
  {"fGapDeceleration", 16, "LREAL", &ZMC_ControlAxisByPosVel::get_fGapDeceleration, &ZMC_ControlAxisByPosVel::set_fGapDeceleration }, 
};
IEC_Property_Range ZMC_ControlAxisByPosVel::property_range_list[] = { 
  {0, 1, 4 }, 
  {1, 1, 5 }, 
  {2, 2, 6 }, 
  {4, 2, 7 }, 
  {6, 3, 8 }, 
  {9, 1, 10 }, 
  {10, 3, 12 }, 
  {13, 1, 15 }, 
  {14, 2, 16 }, 
};

bool ZMC_ControlAxisByPosVel::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int16(writer_, "iStatus", ((iStatus)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bEnable", ((bEnable)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bAvoidGaps", ((bAvoidGaps)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "fSetPosition", ((fSetPosition)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "fSetVelocity", ((fSetVelocity)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "fGapVelocity", ((fGapVelocity)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "fGapAcceleration", ((fGapAcceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "fGapDeceleration", ((fGapDeceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "fGapJerk", ((fGapJerk)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bBusy", ((bBusy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bCommandAborted", ((bCommandAborted)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bError", ((bError)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int16(writer_, "iErrorID", ((iErrorID)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bStopIpo", ((bStopIpo)));
  }
  return true;
}

bool ZMC_ControlAxisByPosVel::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "iStatus", &v_) == RET_OK)
        (iStatus) = value_int16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bEnable", &v_) == RET_OK)
        (bEnable) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bAvoidGaps", &v_) == RET_OK)
        (bAvoidGaps) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "fSetPosition", &v_) == RET_OK)
        (fSetPosition) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "fSetVelocity", &v_) == RET_OK)
        (fSetVelocity) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "fGapVelocity", &v_) == RET_OK)
        (fGapVelocity) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "fGapAcceleration", &v_) == RET_OK)
        (fGapAcceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "fGapDeceleration", &v_) == RET_OK)
        (fGapDeceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "fGapJerk", &v_) == RET_OK)
        (fGapJerk) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bBusy", &v_) == RET_OK)
        (bBusy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bCommandAborted", &v_) == RET_OK)
        (bCommandAborted) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bError", &v_) == RET_OK)
        (bError) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "iErrorID", &v_) == RET_OK)
        (iErrorID) = value_int16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bStopIpo", &v_) == RET_OK)
        (bStopIpo) = value_bool(&v_);
  }
  return true;
}

bool ZMC_ControlAxisByPosVel::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool ZMC_ControlAxisByPosVel::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool ZMC_ControlAxisByVel::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool ZMC_ControlAxisByVel::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_ControlAxisByVel::get_iStatus(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((iStatus)));
  return true;
}
bool ZMC_ControlAxisByVel::get_bEnable(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bEnable)));
  return true;
}
bool ZMC_ControlAxisByVel::get_bAvoidGaps(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bAvoidGaps)));
  return true;
}
bool ZMC_ControlAxisByVel::get_fSetVelocity(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((fSetVelocity)));
  return true;
}
bool ZMC_ControlAxisByVel::get_fGapAcceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((fGapAcceleration)));
  return true;
}
bool ZMC_ControlAxisByVel::get_fGapDeceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((fGapDeceleration)));
  return true;
}
bool ZMC_ControlAxisByVel::get_fGapJerk(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((fGapJerk)));
  return true;
}
bool ZMC_ControlAxisByVel::get_bBusy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bBusy)));
  return true;
}
bool ZMC_ControlAxisByVel::get_bCommandAborted(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bCommandAborted)));
  return true;
}
bool ZMC_ControlAxisByVel::get_bError(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bError)));
  return true;
}
bool ZMC_ControlAxisByVel::get_iErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((iErrorID)));
  return true;
}
bool ZMC_ControlAxisByVel::get_bStopIpo(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bStopIpo)));
  return true;
}
bool ZMC_ControlAxisByVel::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool ZMC_ControlAxisByVel::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_ControlAxisByVel::set_iStatus(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (iStatus) = value_int16(v_);
  return true;
}
bool ZMC_ControlAxisByVel::set_bEnable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bEnable) = value_bool(v_);
  return true;
}
bool ZMC_ControlAxisByVel::set_bAvoidGaps(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bAvoidGaps) = value_bool(v_);
  return true;
}
bool ZMC_ControlAxisByVel::set_fSetVelocity(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (fSetVelocity) = value_double(v_);
  return true;
}
bool ZMC_ControlAxisByVel::set_fGapAcceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (fGapAcceleration) = value_double(v_);
  return true;
}
bool ZMC_ControlAxisByVel::set_fGapDeceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (fGapDeceleration) = value_double(v_);
  return true;
}
bool ZMC_ControlAxisByVel::set_fGapJerk(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (fGapJerk) = value_double(v_);
  return true;
}
bool ZMC_ControlAxisByVel::set_bBusy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bBusy) = value_bool(v_);
  return true;
}
bool ZMC_ControlAxisByVel::set_bCommandAborted(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bCommandAborted) = value_bool(v_);
  return true;
}
bool ZMC_ControlAxisByVel::set_bError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bError) = value_bool(v_);
  return true;
}
bool ZMC_ControlAxisByVel::set_iErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (iErrorID) = value_int16(v_);
  return true;
}
bool ZMC_ControlAxisByVel::set_bStopIpo(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bStopIpo) = value_bool(v_);
  return true;
}

IEC_Property<ZMC_ControlAxisByVel> ZMC_ControlAxisByVel::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &ZMC_ControlAxisByVel::get_Axis, &ZMC_ControlAxisByVel::set_Axis }, 
  {"bBusy", 5, "BOOL", &ZMC_ControlAxisByVel::get_bBusy, &ZMC_ControlAxisByVel::set_bBusy }, 
  {"bError", 6, "BOOL", &ZMC_ControlAxisByVel::get_bError, &ZMC_ControlAxisByVel::set_bError }, 
  {"native", 6, "ULINT", &ZMC_ControlAxisByVel::get_native, &ZMC_ControlAxisByVel::set_native }, 
  {"bEnable", 7, "BOOL", &ZMC_ControlAxisByVel::get_bEnable, &ZMC_ControlAxisByVel::set_bEnable }, 
  {"iStatus", 7, "INT", &ZMC_ControlAxisByVel::get_iStatus, &ZMC_ControlAxisByVel::set_iStatus }, 
  {"bStopIpo", 8, "BOOL", &ZMC_ControlAxisByVel::get_bStopIpo, &ZMC_ControlAxisByVel::set_bStopIpo }, 
  {"fGapJerk", 8, "LREAL", &ZMC_ControlAxisByVel::get_fGapJerk, &ZMC_ControlAxisByVel::set_fGapJerk }, 
  {"iErrorID", 8, "INT", &ZMC_ControlAxisByVel::get_iErrorID, &ZMC_ControlAxisByVel::set_iErrorID }, 
  {"bAvoidGaps", 10, "BOOL", &ZMC_ControlAxisByVel::get_bAvoidGaps, &ZMC_ControlAxisByVel::set_bAvoidGaps }, 
  {"fSetVelocity", 12, "LREAL", &ZMC_ControlAxisByVel::get_fSetVelocity, &ZMC_ControlAxisByVel::set_fSetVelocity }, 
  {"bCommandAborted", 15, "BOOL", &ZMC_ControlAxisByVel::get_bCommandAborted, &ZMC_ControlAxisByVel::set_bCommandAborted }, 
  {"fGapAcceleration", 16, "LREAL", &ZMC_ControlAxisByVel::get_fGapAcceleration, &ZMC_ControlAxisByVel::set_fGapAcceleration }, 
  {"fGapDeceleration", 16, "LREAL", &ZMC_ControlAxisByVel::get_fGapDeceleration, &ZMC_ControlAxisByVel::set_fGapDeceleration }, 
};
IEC_Property_Range ZMC_ControlAxisByVel::property_range_list[] = { 
  {0, 1, 4 }, 
  {1, 1, 5 }, 
  {2, 2, 6 }, 
  {4, 2, 7 }, 
  {6, 3, 8 }, 
  {9, 1, 10 }, 
  {10, 1, 12 }, 
  {11, 1, 15 }, 
  {12, 2, 16 }, 
};

bool ZMC_ControlAxisByVel::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int16(writer_, "iStatus", ((iStatus)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bEnable", ((bEnable)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bAvoidGaps", ((bAvoidGaps)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "fSetVelocity", ((fSetVelocity)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "fGapAcceleration", ((fGapAcceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "fGapDeceleration", ((fGapDeceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "fGapJerk", ((fGapJerk)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bBusy", ((bBusy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bCommandAborted", ((bCommandAborted)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bError", ((bError)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int16(writer_, "iErrorID", ((iErrorID)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bStopIpo", ((bStopIpo)));
  }
  return true;
}

bool ZMC_ControlAxisByVel::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "iStatus", &v_) == RET_OK)
        (iStatus) = value_int16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bEnable", &v_) == RET_OK)
        (bEnable) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bAvoidGaps", &v_) == RET_OK)
        (bAvoidGaps) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "fSetVelocity", &v_) == RET_OK)
        (fSetVelocity) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "fGapAcceleration", &v_) == RET_OK)
        (fGapAcceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "fGapDeceleration", &v_) == RET_OK)
        (fGapDeceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "fGapJerk", &v_) == RET_OK)
        (fGapJerk) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bBusy", &v_) == RET_OK)
        (bBusy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bCommandAborted", &v_) == RET_OK)
        (bCommandAborted) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bError", &v_) == RET_OK)
        (bError) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "iErrorID", &v_) == RET_OK)
        (iErrorID) = value_int16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bStopIpo", &v_) == RET_OK)
        (bStopIpo) = value_bool(&v_);
  }
  return true;
}

bool ZMC_ControlAxisByVel::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool ZMC_ControlAxisByVel::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool ZMC_ReadErrorMsg::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool ZMC_ReadErrorMsg::get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Enable)));
  return true;
}
bool ZMC_ReadErrorMsg::get_Index(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((Index)));
  return true;
}
bool ZMC_ReadErrorMsg::get_ErrorMsg(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_str(v_, ((ErrorMsg)).get());
  return true;
}
bool ZMC_ReadErrorMsg::get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Valid)));
  return true;
}
bool ZMC_ReadErrorMsg::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool ZMC_ReadErrorMsg::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool ZMC_ReadErrorMsg::set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Enable) = value_bool(v_);
  return true;
}
bool ZMC_ReadErrorMsg::set_Index(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Index) = value_uint16(v_);
  return true;
}
bool ZMC_ReadErrorMsg::set_ErrorMsg(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorMsg) = value_str(v_);
  return true;
}
bool ZMC_ReadErrorMsg::set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Valid) = value_bool(v_);
  return true;
}
bool ZMC_ReadErrorMsg::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}

IEC_Property<ZMC_ReadErrorMsg> ZMC_ReadErrorMsg::property_list[] = { 
  {"Busy", 4, "BOOL", &ZMC_ReadErrorMsg::get_Busy, &ZMC_ReadErrorMsg::set_Busy }, 
  {"Index", 5, "WORD", &ZMC_ReadErrorMsg::get_Index, &ZMC_ReadErrorMsg::set_Index }, 
  {"Valid", 5, "BOOL", &ZMC_ReadErrorMsg::get_Valid, &ZMC_ReadErrorMsg::set_Valid }, 
  {"Enable", 6, "BOOL", &ZMC_ReadErrorMsg::get_Enable, &ZMC_ReadErrorMsg::set_Enable }, 
  {"native", 6, "ULINT", &ZMC_ReadErrorMsg::get_native, &ZMC_ReadErrorMsg::set_native }, 
  {"ErrorMsg", 8, "STRING", &ZMC_ReadErrorMsg::get_ErrorMsg, &ZMC_ReadErrorMsg::set_ErrorMsg }, 
};
IEC_Property_Range ZMC_ReadErrorMsg::property_range_list[] = { 
  {0, 1, 4 }, 
  {1, 2, 5 }, 
  {3, 2, 6 }, 
  {5, 1, 8 }, 
};

bool ZMC_ReadErrorMsg::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Enable", ((Enable)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "Index", ((Index)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_str(writer_, "ErrorMsg", ((ErrorMsg)).get());
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Valid", ((Valid)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  return true;
}

bool ZMC_ReadErrorMsg::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Enable", &v_) == RET_OK)
        (Enable) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Index", &v_) == RET_OK)
        (Index) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorMsg", &v_) == RET_OK)
        (ErrorMsg) = value_str(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Valid", &v_) == RET_OK)
        (Valid) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  return true;
}

bool ZMC_ReadErrorMsg::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool ZMC_ReadErrorMsg::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool ZMC_ReadAxisMappingID::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool ZMC_ReadAxisMappingID::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_ReadAxisMappingID::get_Enable(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Enable)));
  return true;
}
bool ZMC_ReadAxisMappingID::get_Valid(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Valid)));
  return true;
}
bool ZMC_ReadAxisMappingID::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool ZMC_ReadAxisMappingID::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool ZMC_ReadAxisMappingID::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool ZMC_ReadAxisMappingID::get_MappingID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((MappingID)));
  return true;
}
bool ZMC_ReadAxisMappingID::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool ZMC_ReadAxisMappingID::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_ReadAxisMappingID::set_Enable(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Enable) = value_bool(v_);
  return true;
}
bool ZMC_ReadAxisMappingID::set_Valid(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Valid) = value_bool(v_);
  return true;
}
bool ZMC_ReadAxisMappingID::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool ZMC_ReadAxisMappingID::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool ZMC_ReadAxisMappingID::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}
bool ZMC_ReadAxisMappingID::set_MappingID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (MappingID) = value_uint16(v_);
  return true;
}

IEC_Property<ZMC_ReadAxisMappingID> ZMC_ReadAxisMappingID::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &ZMC_ReadAxisMappingID::get_Axis, &ZMC_ReadAxisMappingID::set_Axis }, 
  {"Busy", 4, "BOOL", &ZMC_ReadAxisMappingID::get_Busy, &ZMC_ReadAxisMappingID::set_Busy }, 
  {"Error", 5, "BOOL", &ZMC_ReadAxisMappingID::get_Error, &ZMC_ReadAxisMappingID::set_Error }, 
  {"Valid", 5, "BOOL", &ZMC_ReadAxisMappingID::get_Valid, &ZMC_ReadAxisMappingID::set_Valid }, 
  {"Enable", 6, "BOOL", &ZMC_ReadAxisMappingID::get_Enable, &ZMC_ReadAxisMappingID::set_Enable }, 
  {"native", 6, "ULINT", &ZMC_ReadAxisMappingID::get_native, &ZMC_ReadAxisMappingID::set_native }, 
  {"ErrorID", 7, "WORD", &ZMC_ReadAxisMappingID::get_ErrorID, &ZMC_ReadAxisMappingID::set_ErrorID }, 
  {"MappingID", 9, "WORD", &ZMC_ReadAxisMappingID::get_MappingID, &ZMC_ReadAxisMappingID::set_MappingID }, 
};
IEC_Property_Range ZMC_ReadAxisMappingID::property_range_list[] = { 
  {0, 2, 4 }, 
  {2, 2, 5 }, 
  {4, 2, 6 }, 
  {6, 1, 7 }, 
  {7, 1, 9 }, 
};

bool ZMC_ReadAxisMappingID::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Enable", ((Enable)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Valid", ((Valid)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "MappingID", ((MappingID)));
  }
  return true;
}

bool ZMC_ReadAxisMappingID::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Enable", &v_) == RET_OK)
        (Enable) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Valid", &v_) == RET_OK)
        (Valid) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "MappingID", &v_) == RET_OK)
        (MappingID) = value_uint16(&v_);
  }
  return true;
}

bool ZMC_ReadAxisMappingID::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool ZMC_ReadAxisMappingID::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool ZMC_SetMovementType::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool ZMC_SetMovementType::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_SetMovementType::get_bExecute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bExecute)));
  return true;
}
bool ZMC_SetMovementType::get_iMovementType(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((iMovementType)));
  return true;
}
bool ZMC_SetMovementType::get_fPositionPeriod(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((fPositionPeriod)));
  return true;
}
bool ZMC_SetMovementType::get_bDone(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bDone)));
  return true;
}
bool ZMC_SetMovementType::get_bError(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bError)));
  return true;
}
bool ZMC_SetMovementType::get_eErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((eErrorID)));
  return true;
}
bool ZMC_SetMovementType::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool ZMC_SetMovementType::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_SetMovementType::set_bExecute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bExecute) = value_bool(v_);
  return true;
}
bool ZMC_SetMovementType::set_iMovementType(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (iMovementType) = value_int16(v_);
  return true;
}
bool ZMC_SetMovementType::set_fPositionPeriod(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (fPositionPeriod) = value_double(v_);
  return true;
}
bool ZMC_SetMovementType::set_bDone(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bDone) = value_bool(v_);
  return true;
}
bool ZMC_SetMovementType::set_bError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bError) = value_bool(v_);
  return true;
}
bool ZMC_SetMovementType::set_eErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (eErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<ZMC_SetMovementType> ZMC_SetMovementType::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &ZMC_SetMovementType::get_Axis, &ZMC_SetMovementType::set_Axis }, 
  {"bDone", 5, "BOOL", &ZMC_SetMovementType::get_bDone, &ZMC_SetMovementType::set_bDone }, 
  {"bError", 6, "BOOL", &ZMC_SetMovementType::get_bError, &ZMC_SetMovementType::set_bError }, 
  {"native", 6, "ULINT", &ZMC_SetMovementType::get_native, &ZMC_SetMovementType::set_native }, 
  {"bExecute", 8, "BOOL", &ZMC_SetMovementType::get_bExecute, &ZMC_SetMovementType::set_bExecute }, 
  {"eErrorID", 8, "WORD", &ZMC_SetMovementType::get_eErrorID, &ZMC_SetMovementType::set_eErrorID }, 
  {"iMovementType", 13, "INT", &ZMC_SetMovementType::get_iMovementType, &ZMC_SetMovementType::set_iMovementType }, 
  {"fPositionPeriod", 15, "LREAL", &ZMC_SetMovementType::get_fPositionPeriod, &ZMC_SetMovementType::set_fPositionPeriod }, 
};
IEC_Property_Range ZMC_SetMovementType::property_range_list[] = { 
  {0, 1, 4 }, 
  {1, 1, 5 }, 
  {2, 2, 6 }, 
  {4, 2, 8 }, 
  {6, 1, 13 }, 
  {7, 1, 15 }, 
};

bool ZMC_SetMovementType::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bExecute", ((bExecute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int16(writer_, "iMovementType", ((iMovementType)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "fPositionPeriod", ((fPositionPeriod)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bDone", ((bDone)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bError", ((bError)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "eErrorID", ((eErrorID)));
  }
  return true;
}

bool ZMC_SetMovementType::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bExecute", &v_) == RET_OK)
        (bExecute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "iMovementType", &v_) == RET_OK)
        (iMovementType) = value_int16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "fPositionPeriod", &v_) == RET_OK)
        (fPositionPeriod) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bDone", &v_) == RET_OK)
        (bDone) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bError", &v_) == RET_OK)
        (bError) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "eErrorID", &v_) == RET_OK)
        (eErrorID) = value_uint16(&v_);
  }
  return true;
}

bool ZMC_SetMovementType::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool ZMC_SetMovementType::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool ZMC_SetRampType::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool ZMC_SetRampType::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_SetRampType::get_bExecute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bExecute)));
  return true;
}
bool ZMC_SetRampType::get_eRampType(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((eRampType)));
  return true;
}
bool ZMC_SetRampType::get_bDone(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bDone)));
  return true;
}
bool ZMC_SetRampType::get_bError(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bError)));
  return true;
}
bool ZMC_SetRampType::get_eErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((eErrorID)));
  return true;
}
bool ZMC_SetRampType::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool ZMC_SetRampType::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_SetRampType::set_bExecute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bExecute) = value_bool(v_);
  return true;
}
bool ZMC_SetRampType::set_eRampType(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (eRampType) = value_int16(v_);
  return true;
}
bool ZMC_SetRampType::set_bDone(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bDone) = value_bool(v_);
  return true;
}
bool ZMC_SetRampType::set_bError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bError) = value_bool(v_);
  return true;
}
bool ZMC_SetRampType::set_eErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (eErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<ZMC_SetRampType> ZMC_SetRampType::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &ZMC_SetRampType::get_Axis, &ZMC_SetRampType::set_Axis }, 
  {"bDone", 5, "BOOL", &ZMC_SetRampType::get_bDone, &ZMC_SetRampType::set_bDone }, 
  {"bError", 6, "BOOL", &ZMC_SetRampType::get_bError, &ZMC_SetRampType::set_bError }, 
  {"native", 6, "ULINT", &ZMC_SetRampType::get_native, &ZMC_SetRampType::set_native }, 
  {"bExecute", 8, "BOOL", &ZMC_SetRampType::get_bExecute, &ZMC_SetRampType::set_bExecute }, 
  {"eErrorID", 8, "WORD", &ZMC_SetRampType::get_eErrorID, &ZMC_SetRampType::set_eErrorID }, 
  {"eRampType", 9, "INT", &ZMC_SetRampType::get_eRampType, &ZMC_SetRampType::set_eRampType }, 
};
IEC_Property_Range ZMC_SetRampType::property_range_list[] = { 
  {0, 1, 4 }, 
  {1, 1, 5 }, 
  {2, 2, 6 }, 
  {4, 2, 8 }, 
  {6, 1, 9 }, 
};

bool ZMC_SetRampType::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bExecute", ((bExecute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int16(writer_, "eRampType", ((eRampType)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bDone", ((bDone)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bError", ((bError)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "eErrorID", ((eErrorID)));
  }
  return true;
}

bool ZMC_SetRampType::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bExecute", &v_) == RET_OK)
        (bExecute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "eRampType", &v_) == RET_OK)
        (eRampType) = value_int16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bDone", &v_) == RET_OK)
        (bDone) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bError", &v_) == RET_OK)
        (bError) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "eErrorID", &v_) == RET_OK)
        (eErrorID) = value_uint16(&v_);
  }
  return true;
}

bool ZMC_SetRampType::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool ZMC_SetRampType::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool ZMC_SetSoftwareLimits::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool ZMC_SetSoftwareLimits::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_SetSoftwareLimits::get_bExecute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bExecute)));
  return true;
}
bool ZMC_SetSoftwareLimits::get_SWL_Activated(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((SWL_Activated)));
  return true;
}
bool ZMC_SetSoftwareLimits::get_SWL_Positive(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((SWL_Positive)));
  return true;
}
bool ZMC_SetSoftwareLimits::get_SWL_Negative(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((SWL_Negative)));
  return true;
}
bool ZMC_SetSoftwareLimits::get_SWL_Error_Decelerate(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((SWL_Error_Decelerate)));
  return true;
}
bool ZMC_SetSoftwareLimits::get_SWL_Error_Deceleration(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((SWL_Error_Deceleration)));
  return true;
}
bool ZMC_SetSoftwareLimits::get_SWL_Error_MaxDistance(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_double(v_, ((SWL_Error_MaxDistance)));
  return true;
}
bool ZMC_SetSoftwareLimits::get_bDone(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bDone)));
  return true;
}
bool ZMC_SetSoftwareLimits::get_bError(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((bError)));
  return true;
}
bool ZMC_SetSoftwareLimits::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool ZMC_SetSoftwareLimits::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool ZMC_SetSoftwareLimits::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool ZMC_SetSoftwareLimits::set_bExecute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bExecute) = value_bool(v_);
  return true;
}
bool ZMC_SetSoftwareLimits::set_SWL_Activated(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (SWL_Activated) = value_bool(v_);
  return true;
}
bool ZMC_SetSoftwareLimits::set_SWL_Positive(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (SWL_Positive) = value_double(v_);
  return true;
}
bool ZMC_SetSoftwareLimits::set_SWL_Negative(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (SWL_Negative) = value_double(v_);
  return true;
}
bool ZMC_SetSoftwareLimits::set_SWL_Error_Decelerate(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (SWL_Error_Decelerate) = value_bool(v_);
  return true;
}
bool ZMC_SetSoftwareLimits::set_SWL_Error_Deceleration(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (SWL_Error_Deceleration) = value_double(v_);
  return true;
}
bool ZMC_SetSoftwareLimits::set_SWL_Error_MaxDistance(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (SWL_Error_MaxDistance) = value_double(v_);
  return true;
}
bool ZMC_SetSoftwareLimits::set_bDone(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bDone) = value_bool(v_);
  return true;
}
bool ZMC_SetSoftwareLimits::set_bError(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (bError) = value_bool(v_);
  return true;
}
bool ZMC_SetSoftwareLimits::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<ZMC_SetSoftwareLimits> ZMC_SetSoftwareLimits::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &ZMC_SetSoftwareLimits::get_Axis, &ZMC_SetSoftwareLimits::set_Axis }, 
  {"bDone", 5, "BOOL", &ZMC_SetSoftwareLimits::get_bDone, &ZMC_SetSoftwareLimits::set_bDone }, 
  {"bError", 6, "BOOL", &ZMC_SetSoftwareLimits::get_bError, &ZMC_SetSoftwareLimits::set_bError }, 
  {"native", 6, "ULINT", &ZMC_SetSoftwareLimits::get_native, &ZMC_SetSoftwareLimits::set_native }, 
  {"ErrorID", 7, "WORD", &ZMC_SetSoftwareLimits::get_ErrorID, &ZMC_SetSoftwareLimits::set_ErrorID }, 
  {"bExecute", 8, "BOOL", &ZMC_SetSoftwareLimits::get_bExecute, &ZMC_SetSoftwareLimits::set_bExecute }, 
  {"SWL_Negative", 12, "LREAL", &ZMC_SetSoftwareLimits::get_SWL_Negative, &ZMC_SetSoftwareLimits::set_SWL_Negative }, 
  {"SWL_Positive", 12, "LREAL", &ZMC_SetSoftwareLimits::get_SWL_Positive, &ZMC_SetSoftwareLimits::set_SWL_Positive }, 
  {"SWL_Activated", 13, "BOOL", &ZMC_SetSoftwareLimits::get_SWL_Activated, &ZMC_SetSoftwareLimits::set_SWL_Activated }, 
  {"SWL_Error_Decelerate", 20, "BOOL", &ZMC_SetSoftwareLimits::get_SWL_Error_Decelerate, &ZMC_SetSoftwareLimits::set_SWL_Error_Decelerate }, 
  {"SWL_Error_MaxDistance", 21, "LREAL", &ZMC_SetSoftwareLimits::get_SWL_Error_MaxDistance, &ZMC_SetSoftwareLimits::set_SWL_Error_MaxDistance }, 
  {"SWL_Error_Deceleration", 22, "LREAL", &ZMC_SetSoftwareLimits::get_SWL_Error_Deceleration, &ZMC_SetSoftwareLimits::set_SWL_Error_Deceleration }, 
};
IEC_Property_Range ZMC_SetSoftwareLimits::property_range_list[] = { 
  {0, 1, 4 }, 
  {1, 1, 5 }, 
  {2, 2, 6 }, 
  {4, 1, 7 }, 
  {5, 1, 8 }, 
  {6, 2, 12 }, 
  {8, 1, 13 }, 
  {9, 1, 20 }, 
  {10, 1, 21 }, 
  {11, 1, 22 }, 
};

bool ZMC_SetSoftwareLimits::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bExecute", ((bExecute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "SWL_Activated", ((SWL_Activated)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "SWL_Positive", ((SWL_Positive)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "SWL_Negative", ((SWL_Negative)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "SWL_Error_Decelerate", ((SWL_Error_Decelerate)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "SWL_Error_Deceleration", ((SWL_Error_Deceleration)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_double(writer_, "SWL_Error_MaxDistance", ((SWL_Error_MaxDistance)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bDone", ((bDone)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "bError", ((bError)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool ZMC_SetSoftwareLimits::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bExecute", &v_) == RET_OK)
        (bExecute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "SWL_Activated", &v_) == RET_OK)
        (SWL_Activated) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "SWL_Positive", &v_) == RET_OK)
        (SWL_Positive) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "SWL_Negative", &v_) == RET_OK)
        (SWL_Negative) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "SWL_Error_Decelerate", &v_) == RET_OK)
        (SWL_Error_Decelerate) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "SWL_Error_Deceleration", &v_) == RET_OK)
        (SWL_Error_Deceleration) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "SWL_Error_MaxDistance", &v_) == RET_OK)
        (SWL_Error_MaxDistance) = value_double(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bDone", &v_) == RET_OK)
        (bDone) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "bError", &v_) == RET_OK)
        (bError) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool ZMC_SetSoftwareLimits::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool ZMC_SetSoftwareLimits::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool AXIS_GROUP_REF::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool AXIS_GROUP_REF::get_id(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((id)));
  return true;
}
bool AXIS_GROUP_REF::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool AXIS_GROUP_REF::set_id(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (id) = value_int16(v_);
  return true;
}

IEC_Property<AXIS_GROUP_REF> AXIS_GROUP_REF::property_list[] = { 
  {"id", 2, "INT", &AXIS_GROUP_REF::get_id, &AXIS_GROUP_REF::set_id }, 
  {"native", 6, "ULINT", &AXIS_GROUP_REF::get_native, &AXIS_GROUP_REF::set_native }, 
};
IEC_Property_Range AXIS_GROUP_REF::property_range_list[] = { 
  {0, 1, 2 }, 
  {1, 1, 6 }, 
};

bool AXIS_GROUP_REF::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int16(writer_, "id", ((id)));
  }
  return true;
}

bool AXIS_GROUP_REF::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "id", &v_) == RET_OK)
        (id) = value_int16(&v_);
  }
  return true;
}

bool AXIS_GROUP_REF::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool AXIS_GROUP_REF::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MC_AddAxisToGroup::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MC_AddAxisToGroup::get_AxisGroup(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return AxisGroup.get_(name_, v_, obj);
}
bool MC_AddAxisToGroup::get_Axis(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, Axis);
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return Axis->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_AddAxisToGroup::get_Execute(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Execute)));
  return true;
}
bool MC_AddAxisToGroup::get_Done(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Done)));
  return true;
}
bool MC_AddAxisToGroup::get_Busy(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Busy)));
  return true;
}
bool MC_AddAxisToGroup::get_Error(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((Error)));
  return true;
}
bool MC_AddAxisToGroup::get_ErrorID(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((ErrorID)));
  return true;
}
bool MC_AddAxisToGroup::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}
bool MC_AddAxisToGroup::set_AxisGroup(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return AxisGroup.set_(name_, v_, obj);
}
bool MC_AddAxisToGroup::set_Axis(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    Axis = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || Axis == NULL) { return false; }

  return Axis->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
bool MC_AddAxisToGroup::set_Execute(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Execute) = value_bool(v_);
  return true;
}
bool MC_AddAxisToGroup::set_Done(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Done) = value_bool(v_);
  return true;
}
bool MC_AddAxisToGroup::set_Busy(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Busy) = value_bool(v_);
  return true;
}
bool MC_AddAxisToGroup::set_Error(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (Error) = value_bool(v_);
  return true;
}
bool MC_AddAxisToGroup::set_ErrorID(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (ErrorID) = value_uint16(v_);
  return true;
}

IEC_Property<MC_AddAxisToGroup> MC_AddAxisToGroup::property_list[] = { 
  {"Axis", 4, "POINTER TO AXIS_BASE", &MC_AddAxisToGroup::get_Axis, &MC_AddAxisToGroup::set_Axis }, 
  {"Busy", 4, "BOOL", &MC_AddAxisToGroup::get_Busy, &MC_AddAxisToGroup::set_Busy }, 
  {"Done", 4, "BOOL", &MC_AddAxisToGroup::get_Done, &MC_AddAxisToGroup::set_Done }, 
  {"Error", 5, "BOOL", &MC_AddAxisToGroup::get_Error, &MC_AddAxisToGroup::set_Error }, 
  {"native", 6, "ULINT", &MC_AddAxisToGroup::get_native, &MC_AddAxisToGroup::set_native }, 
  {"ErrorID", 7, "WORD", &MC_AddAxisToGroup::get_ErrorID, &MC_AddAxisToGroup::set_ErrorID }, 
  {"Execute", 7, "BOOL", &MC_AddAxisToGroup::get_Execute, &MC_AddAxisToGroup::set_Execute }, 
  {"AxisGroup", 9, "AXIS_GROUP_REF", &MC_AddAxisToGroup::get_AxisGroup, &MC_AddAxisToGroup::set_AxisGroup }, 
};
IEC_Property_Range MC_AddAxisToGroup::property_range_list[] = { 
  {0, 3, 4 }, 
  {3, 1, 5 }, 
  {4, 1, 6 }, 
  {5, 2, 7 }, 
  {7, 1, 9 }, 
};

bool MC_AddAxisToGroup::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
      ubjson_writer_write_kv_object_begin(writer_, "AxisGroup");
      AxisGroup.save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "Axis");
      Axis->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Execute", ((Execute)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Done", ((Done)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Busy", ((Busy)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "Error", ((Error)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "ErrorID", ((ErrorID)));
  }
  return true;
}

bool MC_AddAxisToGroup::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      conf_node_t* sub = conf_node_find_child(parent_, "AxisGroup");
      if (sub != nullptr) AxisGroup.load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (Axis != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Axis");
      if (sub != nullptr) Axis->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Execute", &v_) == RET_OK)
        (Execute) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Done", &v_) == RET_OK)
        (Done) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Busy", &v_) == RET_OK)
        (Busy) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "Error", &v_) == RET_OK)
        (Error) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "ErrorID", &v_) == RET_OK)
        (ErrorID) = value_uint16(&v_);
  }
  return true;
}

bool MC_AddAxisToGroup::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MC_AddAxisToGroup::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool MODBUS_SLAVE_IO::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool MODBUS_SLAVE_IO::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}

IEC_Property<MODBUS_SLAVE_IO> MODBUS_SLAVE_IO::property_list[] = { 
  {"native", 6, "ULINT", &MODBUS_SLAVE_IO::get_native, &MODBUS_SLAVE_IO::set_native }, 
};
IEC_Property_Range MODBUS_SLAVE_IO::property_range_list[] = { 
  {0, 1, 6 }, 
};

bool MODBUS_SLAVE_IO::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  return true;
}

bool MODBUS_SLAVE_IO::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  return true;
}

bool MODBUS_SLAVE_IO::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool MODBUS_SLAVE_IO::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool LOCAL_EQEP::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool LOCAL_EQEP::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}

IEC_Property<LOCAL_EQEP> LOCAL_EQEP::property_list[] = { 
  {"native", 6, "ULINT", &LOCAL_EQEP::get_native, &LOCAL_EQEP::set_native }, 
};
IEC_Property_Range LOCAL_EQEP::property_range_list[] = { 
  {0, 1, 6 }, 
};

bool LOCAL_EQEP::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  return true;
}

bool LOCAL_EQEP::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  return true;
}

bool LOCAL_EQEP::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool LOCAL_EQEP::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool LOCAL_IO::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool LOCAL_IO::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}

IEC_Property<LOCAL_IO> LOCAL_IO::property_list[] = { 
  {"native", 6, "ULINT", &LOCAL_IO::get_native, &LOCAL_IO::set_native }, 
};
IEC_Property_Range LOCAL_IO::property_range_list[] = { 
  {0, 1, 6 }, 
};

bool LOCAL_IO::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  return true;
}

bool LOCAL_IO::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  return true;
}

bool LOCAL_IO::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool LOCAL_IO::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool LOCAL_PWM::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool LOCAL_PWM::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}

IEC_Property<LOCAL_PWM> LOCAL_PWM::property_list[] = { 
  {"native", 6, "ULINT", &LOCAL_PWM::get_native, &LOCAL_PWM::set_native }, 
};
IEC_Property_Range LOCAL_PWM::property_range_list[] = { 
  {0, 1, 6 }, 
};

bool LOCAL_PWM::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  return true;
}

bool LOCAL_PWM::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  return true;
}

bool LOCAL_PWM::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool LOCAL_PWM::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool CANOPEN_MASTER_IO::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool CANOPEN_MASTER_IO::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}

IEC_Property<CANOPEN_MASTER_IO> CANOPEN_MASTER_IO::property_list[] = { 
  {"native", 6, "ULINT", &CANOPEN_MASTER_IO::get_native, &CANOPEN_MASTER_IO::set_native }, 
};
IEC_Property_Range CANOPEN_MASTER_IO::property_range_list[] = { 
  {0, 1, 6 }, 
};

bool CANOPEN_MASTER_IO::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  return true;
}

bool CANOPEN_MASTER_IO::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  return true;
}

bool CANOPEN_MASTER_IO::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool CANOPEN_MASTER_IO::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool CANOPEN_SLAVE_IO::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool CANOPEN_SLAVE_IO::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}

IEC_Property<CANOPEN_SLAVE_IO> CANOPEN_SLAVE_IO::property_list[] = { 
  {"native", 6, "ULINT", &CANOPEN_SLAVE_IO::get_native, &CANOPEN_SLAVE_IO::set_native }, 
};
IEC_Property_Range CANOPEN_SLAVE_IO::property_range_list[] = { 
  {0, 1, 6 }, 
};

bool CANOPEN_SLAVE_IO::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  return true;
}

bool CANOPEN_SLAVE_IO::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  return true;
}

bool CANOPEN_SLAVE_IO::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool CANOPEN_SLAVE_IO::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool EIP_SLAVE_IO::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool EIP_SLAVE_IO::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}

IEC_Property<EIP_SLAVE_IO> EIP_SLAVE_IO::property_list[] = { 
  {"native", 6, "ULINT", &EIP_SLAVE_IO::get_native, &EIP_SLAVE_IO::set_native }, 
};
IEC_Property_Range EIP_SLAVE_IO::property_range_list[] = { 
  {0, 1, 6 }, 
};

bool EIP_SLAVE_IO::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  return true;
}

bool EIP_SLAVE_IO::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  return true;
}

bool EIP_SLAVE_IO::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool EIP_SLAVE_IO::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool OPCUA_IO::get_native(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint64(v_, ((native)));
  return true;
}
bool OPCUA_IO::set_native(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (native) = value_uint64(v_);
  return true;
}

IEC_Property<OPCUA_IO> OPCUA_IO::property_list[] = { 
  {"native", 6, "ULINT", &OPCUA_IO::get_native, &OPCUA_IO::set_native }, 
};
IEC_Property_Range OPCUA_IO::property_range_list[] = { 
  {0, 1, 6 }, 
};

bool OPCUA_IO::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint64(writer_, "native", ((native)));
  }
  return true;
}

bool OPCUA_IO::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "native", &v_) == RET_OK)
        (native) = value_uint64(&v_);
  }
  return true;
}

bool OPCUA_IO::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool OPCUA_IO::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
bool main::get_BTN_RUN(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((BTN_RUN)).get());
  return true;
}
bool main::get_BTN_STOP(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((BTN_STOP)).get());
  return true;
}
bool main::get_BTN_CLOSE(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((BTN_CLOSE)).get());
  return true;
}
bool main::get_LED_RED(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((LED_RED)).get());
  return true;
}
bool main::get_LED_GREEN(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((LED_GREEN)).get());
  return true;
}
bool main::get_count(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_uint16(v_, ((count)));
  return true;
}
bool main::get_mPower(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((mPower)));
  return true;
}
bool main::get_mReset(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((mReset)));
  return true;
}
bool main::get_mMoveRel(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((mMoveRel)));
  return true;
}
bool main::get_mStop(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((mStop)));
  return true;
}
bool main::get_mDisRel(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_int16(v_, ((mDisRel)));
  return true;
}
bool main::get_mDone(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((mDone)));
  return true;
}
bool main::get_Power(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return Power.get_(name_, v_, obj);
}
bool main::get_Reset(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return Reset.get_(name_, v_, obj);
}
bool main::get_Stop(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return Stop.get_(name_, v_, obj);
}
bool main::get_MoveRel(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return MoveRel.get_(name_, v_, obj);
}
bool main::get_Halt(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return Halt.get_(name_, v_, obj);
}
bool main::get_Tick(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return Tick.get_(name_, v_, obj);
}
bool main::get_mLEDReverse(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((mLEDReverse)));
  return true;
}
bool main::get_mRunCmd(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((mRunCmd)));
  return true;
}
bool main::get_mStopCmd(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((mStopCmd)));
  return true;
}
bool main::get_mHalt(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  value_set_bool(v_, ((mHalt)));
  return true;
}
bool main::set_BTN_RUN(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (BTN_RUN) = value_bool(v_);
  return true;
}
bool main::set_BTN_STOP(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (BTN_STOP) = value_bool(v_);
  return true;
}
bool main::set_BTN_CLOSE(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (BTN_CLOSE) = value_bool(v_);
  return true;
}
bool main::set_LED_RED(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (LED_RED) = value_bool(v_);
  return true;
}
bool main::set_LED_GREEN(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (LED_GREEN) = value_bool(v_);
  return true;
}
bool main::set_count(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (count) = value_uint16(v_);
  return true;
}
bool main::set_mPower(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (mPower) = value_bool(v_);
  return true;
}
bool main::set_mReset(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (mReset) = value_bool(v_);
  return true;
}
bool main::set_mMoveRel(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (mMoveRel) = value_bool(v_);
  return true;
}
bool main::set_mStop(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (mStop) = value_bool(v_);
  return true;
}
bool main::set_mDisRel(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (mDisRel) = value_int16(v_);
  return true;
}
bool main::set_mDone(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (mDone) = value_bool(v_);
  return true;
}
bool main::set_Power(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return Power.set_(name_, v_, obj);
}
bool main::set_Reset(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return Reset.set_(name_, v_, obj);
}
bool main::set_Stop(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return Stop.set_(name_, v_, obj);
}
bool main::set_MoveRel(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return MoveRel.set_(name_, v_, obj);
}
bool main::set_Halt(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return Halt.set_(name_, v_, obj);
}
bool main::set_Tick(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return Tick.set_(name_, v_, obj);
}
bool main::set_mLEDReverse(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (mLEDReverse) = value_bool(v_);
  return true;
}
bool main::set_mRunCmd(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (mRunCmd) = value_bool(v_);
  return true;
}
bool main::set_mStopCmd(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (mStopCmd) = value_bool(v_);
  return true;
}
bool main::set_mHalt(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  (void)obj;
  (void)name_;
  (mHalt) = value_bool(v_);
  return true;
}

IEC_Property<main> main::property_list[] = { 
  {"Halt", 4, "MC_Halt", &main::get_Halt, &main::set_Halt }, 
  {"Stop", 4, "MC_Stop", &main::get_Stop, &main::set_Stop }, 
  {"Tick", 4, "TON", &main::get_Tick, &main::set_Tick }, 
  {"Power", 5, "MC_Power", &main::get_Power, &main::set_Power }, 
  {"Reset", 5, "MC_Reset", &main::get_Reset, &main::set_Reset }, 
  {"count", 5, "WORD", &main::get_count, &main::set_count }, 
  {"mDone", 5, "BOOL", &main::get_mDone, &main::set_mDone }, 
  {"mHalt", 5, "BOOL", &main::get_mHalt, &main::set_mHalt }, 
  {"mStop", 5, "BOOL", &main::get_mStop, &main::set_mStop }, 
  {"mPower", 6, "BOOL", &main::get_mPower, &main::set_mPower }, 
  {"mReset", 6, "BOOL", &main::get_mReset, &main::set_mReset }, 
  {"BTN_RUN", 7, "BOOL", &main::get_BTN_RUN, &main::set_BTN_RUN }, 
  {"LED_RED", 7, "BOOL", &main::get_LED_RED, &main::set_LED_RED }, 
  {"MoveRel", 7, "MC_MoveRelative", &main::get_MoveRel, &main::set_MoveRel }, 
  {"mDisRel", 7, "INT", &main::get_mDisRel, &main::set_mDisRel }, 
  {"mRunCmd", 7, "BOOL", &main::get_mRunCmd, &main::set_mRunCmd }, 
  {"BTN_STOP", 8, "BOOL", &main::get_BTN_STOP, &main::set_BTN_STOP }, 
  {"mMoveRel", 8, "BOOL", &main::get_mMoveRel, &main::set_mMoveRel }, 
  {"mStopCmd", 8, "BOOL", &main::get_mStopCmd, &main::set_mStopCmd }, 
  {"BTN_CLOSE", 9, "BOOL", &main::get_BTN_CLOSE, &main::set_BTN_CLOSE }, 
  {"LED_GREEN", 9, "BOOL", &main::get_LED_GREEN, &main::set_LED_GREEN }, 
  {"mLEDReverse", 11, "BOOL", &main::get_mLEDReverse, &main::set_mLEDReverse }, 
};
IEC_Property_Range main::property_range_list[] = { 
  {0, 3, 4 }, 
  {3, 6, 5 }, 
  {9, 2, 6 }, 
  {11, 5, 7 }, 
  {16, 3, 8 }, 
  {19, 2, 9 }, 
  {21, 1, 11 }, 
};

bool main::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "BTN_RUN", ((BTN_RUN)).get());
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "BTN_STOP", ((BTN_STOP)).get());
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "BTN_CLOSE", ((BTN_CLOSE)).get());
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "LED_RED", ((LED_RED)).get());
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "LED_GREEN", ((LED_GREEN)).get());
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_uint16(writer_, "count", ((count)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "mPower", ((mPower)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "mReset", ((mReset)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "mMoveRel", ((mMoveRel)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "mStop", ((mStop)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_int16(writer_, "mDisRel", ((mDisRel)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "mDone", ((mDone)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
      ubjson_writer_write_kv_object_begin(writer_, "Power");
      Power.save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
      ubjson_writer_write_kv_object_begin(writer_, "Reset");
      Reset.save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
      ubjson_writer_write_kv_object_begin(writer_, "Stop");
      Stop.save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
      ubjson_writer_write_kv_object_begin(writer_, "MoveRel");
      MoveRel.save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
      ubjson_writer_write_kv_object_begin(writer_, "Halt");
      Halt.save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
      ubjson_writer_write_kv_object_begin(writer_, "Tick");
      Tick.save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "mLEDReverse", ((mLEDReverse)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "mRunCmd", ((mRunCmd)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "mStopCmd", ((mStopCmd)));
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
    st_ubjson_write_kv_bool(writer_, "mHalt", ((mHalt)));
  }
  return true;
}

bool main::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  value_t v_;
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "BTN_RUN", &v_) == RET_OK)
        (BTN_RUN) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "BTN_STOP", &v_) == RET_OK)
        (BTN_STOP) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "BTN_CLOSE", &v_) == RET_OK)
        (BTN_CLOSE) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "LED_RED", &v_) == RET_OK)
        (LED_RED) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "LED_GREEN", &v_) == RET_OK)
        (LED_GREEN) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "count", &v_) == RET_OK)
        (count) = value_uint16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "mPower", &v_) == RET_OK)
        (mPower) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "mReset", &v_) == RET_OK)
        (mReset) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "mMoveRel", &v_) == RET_OK)
        (mMoveRel) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "mStop", &v_) == RET_OK)
        (mStop) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "mDisRel", &v_) == RET_OK)
        (mDisRel) = value_int16(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "mDone", &v_) == RET_OK)
        (mDone) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Power");
      if (sub != nullptr) Power.load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Reset");
      if (sub != nullptr) Reset.load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Stop");
      if (sub != nullptr) Stop.load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      conf_node_t* sub = conf_node_find_child(parent_, "MoveRel");
      if (sub != nullptr) MoveRel.load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Halt");
      if (sub != nullptr) Halt.load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Tick");
      if (sub != nullptr) Tick.load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "mLEDReverse", &v_) == RET_OK)
        (mLEDReverse) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "mRunCmd", &v_) == RET_OK)
        (mRunCmd) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "mStopCmd", &v_) == RET_OK)
        (mStopCmd) = value_bool(&v_);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      if(conf_node_get_child_value(parent_, "mHalt", &v_) == RET_OK)
        (mHalt) = value_bool(&v_);
  }
  return true;
}

bool main::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}

bool main::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(this, property_list, ARRAY_SIZE(property_list), property_range_list, ARRAY_SIZE(property_range_list), name_, v_, obj);
}
main* main::instance;

bool SYSTEM_INIT::save_(ubjson_writer_t* writer_, iec_save_type_t type_, revertible_str_t* _path_name) {
  return true;
}

bool SYSTEM_INIT::load_(conf_node_t* parent_, iec_load_type_t type_, revertible_str_t* _path_name) {
  return true;
}

bool SYSTEM_INIT::get_(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(this, name_, v_);
}

bool SYSTEM_INIT::set_(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return false;
}
SYSTEM_INIT* SYSTEM_INIT::instance;
ret_t TasksConfig_init_(void) {
  IEC_Configuration* TasksConfig = new IEC_Configuration("TasksConfig");
  IEC_PLC::instance()->add_configuration(TasksConfig);
  IEC_Resource* TasksRes = new IEC_Resource("TasksRes", "PLC");
  TasksConfig->add_resource(TasksRes);
  iec_task_threads_set_attr("MainTask_thread", 1, "FIFO", 1);
  IEC_Task* MainTask = new IEC_Task("MainTask", "EtherCAT_master_2_cycle", 0, "MainTask_thread");
  TasksRes->add_task(MainTask);
  IEC_Program* MainTask_main = main::create();
  MainTask_main->set_type("main");
  MainTask_main->set_name("MainTask_main");
  MainTask->add_program(MainTask_main);
  TasksRes->add_program(MainTask_main);
  if (main::instance == NULL) {main::create(); main::instance->init_();}
  if (SYSTEM_INIT::instance == NULL) {SYSTEM_INIT::create(); SYSTEM_INIT::instance->init_();}
  return RET_OK;
}


uint32_t _plc_get_min_interval(void) {
  return IEC_MIN_INTERVAL_;
}

ret_t _plc_init(void) {
  AXIS_BASE::init_static_();
  DEV_VAR_global_var_list_type_def::init_static_();
  ECAT_MASTER_KPA_IO::init_static_();
  ETC_CO_SdoRead::init_static_();
  ETC_CO_SdoWrite::init_static_();
  MODBUS_MASTER_IO::init_static_();
  AXIS_CIA402_IO::init_static_();
  AXIS_FREE_ENCODER_IO::init_static_();
  AXIS_VIRTUAL_IO::init_static_();
  MC_AbortTrigger::init_static_();
  MC_AccelerationProfile::init_static_();
  MC_CamIn::init_static_();
  MC_CamOut::init_static_();
  MC_CamTableSelect::init_static_();
  MC_DigitalCamSwitch::init_static_();
  MC_GearIn::init_static_();
  MC_GearInPos::init_static_();
  MC_GearOut::init_static_();
  MC_Halt::init_static_();
  MC_Home::init_static_();
  MC_Jog::init_static_();
  MC_MoveAbsolute::init_static_();
  MC_MoveAdditive::init_static_();
  MC_MoveContinuousAbsolute::init_static_();
  MC_MoveContinuousRelative::init_static_();
  MC_MoveRelative::init_static_();
  MC_MoveSuperImposed::init_static_();
  MC_MoveVelocity::init_static_();
  MC_Phasing::init_static_();
  MC_PositionProfile::init_static_();
  MC_Power::init_static_();
  MC_ReadActualPosition::init_static_();
  MC_ReadActualTorque::init_static_();
  MC_ReadActualVelocity::init_static_();
  MC_ReadAxisError::init_static_();
  MC_ReadBoolParameter::init_static_();
  MC_ReadCommandPosition::init_static_();
  MC_ReadParameter::init_static_();
  MC_ReadStatus::init_static_();
  MC_Reset::init_static_();
  MC_SetPosition::init_static_();
  MC_Stop::init_static_();
  MC_TouchProbe::init_static_();
  MC_VelocityProfile::init_static_();
  MC_WriteBoolParameter::init_static_();
  MC_WriteParameter::init_static_();
  ZMC_FollowPosition::init_static_();
  ZMC_GetTappetValue::init_static_();
  ZMC_ReadCAM::init_static_();
  ZMC_WriteCAM::init_static_();
  MC_ReadActualDriveValues::init_static_();
  MC_ReadActualValues::init_static_();
  MC_ReadSetDriveValues::init_static_();
  MC_ReadSetValues::init_static_();
  ZMC_ChangeGearingRatio::init_static_();
  ZMC_CheckLimits::init_static_();
  ZMC_ControlAxisByPos::init_static_();
  ZMC_ControlAxisByPosVel::init_static_();
  ZMC_ControlAxisByVel::init_static_();
  ZMC_ReadErrorMsg::init_static_();
  ZMC_ReadAxisMappingID::init_static_();
  ZMC_SetMovementType::init_static_();
  ZMC_SetRampType::init_static_();
  ZMC_SetSoftwareLimits::init_static_();
  AXIS_GROUP_REF::init_static_();
  MC_AddAxisToGroup::init_static_();
  MODBUS_SLAVE_IO::init_static_();
  LOCAL_EQEP::init_static_();
  LOCAL_IO::init_static_();
  LOCAL_PWM::init_static_();
  CANOPEN_MASTER_IO::init_static_();
  CANOPEN_SLAVE_IO::init_static_();
  EIP_SLAVE_IO::init_static_();
  OPCUA_IO::init_static_();
  CiA402_AXIS_0 = NULL;
  DEV_VAR_global_var_list_type_def_init_(&(DEV_VAR));
  TasksConfig_init_();
  LOCAL_IO_init_(&(Local_Hardware_IO));
  ECAT_MASTER_KPA_IO_init_(&(EtherCAT_master_2));
  AXIS_BASE_init_(&(Motor_7_1));
  AXIS_CIA402_IO_init_(&(Motor_CiA402_7_1));
  LOCAL_IO_Local_Hardware_IO_init_();
  ECAT_MASTER_KPA_IO_EtherCAT_master_2_init_();
  AXIS_BASE_Motor_7_1_init_();
  AXIS_CIA402_IO_Motor_CiA402_7_1_init_();
  LOCAL_IO_Local_Hardware_IO_wait_for_comm();
  ECAT_MASTER_KPA_IO_EtherCAT_master_2_wait_for_comm();
  AXIS_BASE_Motor_7_1_wait_for_comm();
  AXIS_CIA402_IO_Motor_CiA402_7_1_wait_for_comm();
  return RET_OK;
}

bool _plc_global_save(ubjson_writer_t* writer_, iec_save_type_t type_) {
  revertible_str_t __path_name;
  revertible_str_t* _path_name = &__path_name;
  revertible_str_init(_path_name, 128, 32);
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN) && (CiA402_AXIS_0 != NULL)) {
      ubjson_writer_write_kv_object_begin(writer_, "CiA402_AXIS_0");
      CiA402_AXIS_0->save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
      ubjson_writer_write_kv_object_begin(writer_, "DEV_VAR");
      DEV_VAR.save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
      ubjson_writer_write_kv_object_begin(writer_, "Local_Hardware_IO");
      Local_Hardware_IO.save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
      ubjson_writer_write_kv_object_begin(writer_, "EtherCAT_master_2");
      EtherCAT_master_2.save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
      ubjson_writer_write_kv_object_begin(writer_, "Motor_7_1");
      Motor_7_1.save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  if((type_ == IEC_SAVE_ALL || type_ == IEC_SAVE_ALL_EXCEPT_NONRATAIN)) {
      ubjson_writer_write_kv_object_begin(writer_, "Motor_CiA402_7_1");
      Motor_CiA402_7_1.save_(writer_, type_, nullptr);
      ubjson_writer_write_object_end(writer_);
  }
  revertible_str_deinit(_path_name);
  return true;
}

bool _plc_global_load(conf_node_t* parent_, iec_load_type_t type_) {
  value_t v_;
  revertible_str_t __path_name;
  revertible_str_t* _path_name = &__path_name;
  revertible_str_init(_path_name, 128, 32);
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN) && (CiA402_AXIS_0 != NULL)) {
      conf_node_t* sub = conf_node_find_child(parent_, "CiA402_AXIS_0");
      if (sub != nullptr) CiA402_AXIS_0->load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      conf_node_t* sub = conf_node_find_child(parent_, "DEV_VAR");
      if (sub != nullptr) DEV_VAR.load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Local_Hardware_IO");
      if (sub != nullptr) Local_Hardware_IO.load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      conf_node_t* sub = conf_node_find_child(parent_, "EtherCAT_master_2");
      if (sub != nullptr) EtherCAT_master_2.load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Motor_7_1");
      if (sub != nullptr) Motor_7_1.load_(sub, type_, nullptr);
  }
  if((type_ == IEC_LOAD_ALL || type_ == IEC_LOAD_ALL_EXCEPT_NONRATAIN)) {
      conf_node_t* sub = conf_node_find_child(parent_, "Motor_CiA402_7_1");
      if (sub != nullptr) Motor_CiA402_7_1.load_(sub, type_, nullptr);
  }
  revertible_str_deinit(_path_name);
  return true;
}

static bool _plc_global_get_CiA402_AXIS_0(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    value_set_pointer(v_, CiA402_AXIS_0);
    return true;
  } else if (*name_ != '^' || CiA402_AXIS_0 == NULL) { return false; }
  if (*name_ == '^' && *(name_ + 1) == 0) { name_ = NULL; }
  return CiA402_AXIS_0->get_(tk_str_skip_object_prefix(name_), v_, obj);
}
static bool _plc_global_get_DEV_VAR(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return DEV_VAR.get_(name_, v_, obj);
}
static bool _plc_global_get_Local_Hardware_IO(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return Local_Hardware_IO.get_(name_, v_, obj);
}
static bool _plc_global_get_EtherCAT_master_2(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return EtherCAT_master_2.get_(name_, v_, obj);
}
static bool _plc_global_get_Motor_7_1(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return Motor_7_1.get_(name_, v_, obj);
}
static bool _plc_global_get_Motor_CiA402_7_1(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return Motor_CiA402_7_1.get_(name_, v_, obj);
}
static bool _plc_global_set_CiA402_AXIS_0(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  if (name_ == NULL) {
    CiA402_AXIS_0 = static_cast<AXIS_REF >(value_pointer(v_));
    return true;
  } else if (*name_ != '^' || CiA402_AXIS_0 == NULL) { return false; }

  return CiA402_AXIS_0->set_(tk_str_skip_object_prefix(name_), v_, obj);
}
static bool _plc_global_set_DEV_VAR(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return DEV_VAR.set_(name_, v_, obj);
}
static bool _plc_global_set_Local_Hardware_IO(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return Local_Hardware_IO.set_(name_, v_, obj);
}
static bool _plc_global_set_EtherCAT_master_2(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return EtherCAT_master_2.set_(name_, v_, obj);
}
static bool _plc_global_set_Motor_7_1(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return Motor_7_1.set_(name_, v_, obj);
}
static bool _plc_global_set_Motor_CiA402_7_1(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return Motor_CiA402_7_1.set_(name_, v_, obj);
}
static IEC_Global_Property _plc_global_property_list[] = { 
  {"DEV_VAR", 7, "DEV_VAR_global_var_list_type_def", _plc_global_get_DEV_VAR, _plc_global_set_DEV_VAR }, 
  {"Motor_7_1", 9, "AXIS_BASE", _plc_global_get_Motor_7_1, _plc_global_set_Motor_7_1 }, 
  {"CiA402_AXIS_0", 13, "POINTER TO AXIS_BASE", _plc_global_get_CiA402_AXIS_0, _plc_global_set_CiA402_AXIS_0 }, 
  {"Motor_CiA402_7_1", 16, "AXIS_CIA402_IO", _plc_global_get_Motor_CiA402_7_1, _plc_global_set_Motor_CiA402_7_1 }, 
  {"EtherCAT_master_2", 17, "ECAT_MASTER_KPA_IO", _plc_global_get_EtherCAT_master_2, _plc_global_set_EtherCAT_master_2 }, 
  {"Local_Hardware_IO", 17, "LOCAL_IO", _plc_global_get_Local_Hardware_IO, _plc_global_set_Local_Hardware_IO }, 
};
IEC_Property_Range _plc_global_property_range_list[] = { 
  {0, 1, 7 }, 
  {1, 1, 9 }, 
  {2, 1, 13 }, 
  {3, 1, 16 }, 
  {4, 2, 17 }, 
};

extern "C" bool _plc_global_self_get_by_index(void* iec_base, uint32_t index_, const char* sub_name, value_t* v_) {
  return _plc_global_property_list[index_].get_(sub_name, v_, NULL);
}

extern "C" bool _plc_global_self_set_by_index(void* iec_base, uint32_t index_, const char* sub_name, const value_t* v_) {
  if (_plc_global_property_list[index_].set_ != nullptr) {
    return _plc_global_property_list[index_].set_(sub_name, v_, NULL);
  } else {
    return false;
  }
}

bool _plc_global_get(const char* name_, value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_get(_plc_global_property_list, ARRAY_SIZE(_plc_global_property_list), _plc_global_property_range_list, ARRAY_SIZE(_plc_global_property_range_list), name_, v_, obj);
}

bool _plc_global_set(const char* name_, const value_t* v_, IEC_Property_OBJ* obj) {
  return IEC_Base_set(_plc_global_property_list, ARRAY_SIZE(_plc_global_property_list), _plc_global_property_range_list, ARRAY_SIZE(_plc_global_property_range_list), name_, v_, obj);
}

