text: // generated from rosidl_generator_py/resource/_idl_pkg_typesupport_entry_point.c.em
  // generated code does not contain a copyright notice
  #include <Python.h>
  
  static PyMethodDef deepracer_interfaces_pkg__methods[] = {
    {NULL, NULL, 0, NULL}  /* sentinel */
  };
  
  static struct PyModuleDef deepracer_interfaces_pkg__module = {
    PyModuleDef_HEAD_INIT,
    "_deepracer_interfaces_pkg_support",
    "_deepracer_interfaces_pkg_doc",
    -1,  /* -1 means that the module keeps state in global variables */
    deepracer_interfaces_pkg__methods,
    NULL,
    NULL,
    NULL,
    NULL,
  };
  
  #include <stdbool.h>
  #include <stdint.h>
  #include "rosidl_runtime_c/visibility_control.h"
  #include "rosidl_runtime_c/message_type_support_struct.h"
  #include "rosidl_runtime_c/service_type_support_struct.h"
  #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/msg/detail/camera_msg__type_support.h"
  #include "deepracer_interfaces_pkg/msg/detail/camera_msg__struct.h"
  #include "deepracer_interfaces_pkg/msg/detail/camera_msg__functions.h"
  
  static void * deepracer_interfaces_pkg__msg__camera_msg__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__msg__CameraMsg__create();
  }
  
  static void deepracer_interfaces_pkg__msg__camera_msg__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__msg__CameraMsg * ros_message = (deepracer_interfaces_pkg__msg__CameraMsg *)raw_ros_message;
    deepracer_interfaces_pkg__msg__CameraMsg__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__msg__camera_msg__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__msg__camera_msg__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, msg, CameraMsg);
  
  int8_t
  _register_msg_type__msg__camera_msg(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__camera_msg__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__msg__camera_msg",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__camera_msg__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__msg__camera_msg",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__camera_msg__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__msg__camera_msg",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__camera_msg__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__msg__camera_msg",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, msg, CameraMsg),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__msg__camera_msg",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/msg/detail/infer_results__type_support.h"
  #include "deepracer_interfaces_pkg/msg/detail/infer_results__struct.h"
  #include "deepracer_interfaces_pkg/msg/detail/infer_results__functions.h"
  
  static void * deepracer_interfaces_pkg__msg__infer_results__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__msg__InferResults__create();
  }
  
  static void deepracer_interfaces_pkg__msg__infer_results__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__msg__InferResults * ros_message = (deepracer_interfaces_pkg__msg__InferResults *)raw_ros_message;
    deepracer_interfaces_pkg__msg__InferResults__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__msg__infer_results__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__msg__infer_results__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, msg, InferResults);
  
  int8_t
  _register_msg_type__msg__infer_results(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__infer_results__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__msg__infer_results",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__infer_results__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__msg__infer_results",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__infer_results__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__msg__infer_results",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__infer_results__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__msg__infer_results",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, msg, InferResults),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__msg__infer_results",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/msg/detail/infer_results_array__type_support.h"
  #include "deepracer_interfaces_pkg/msg/detail/infer_results_array__struct.h"
  #include "deepracer_interfaces_pkg/msg/detail/infer_results_array__functions.h"
  
  static void * deepracer_interfaces_pkg__msg__infer_results_array__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__msg__InferResultsArray__create();
  }
  
  static void deepracer_interfaces_pkg__msg__infer_results_array__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__msg__InferResultsArray * ros_message = (deepracer_interfaces_pkg__msg__InferResultsArray *)raw_ros_message;
    deepracer_interfaces_pkg__msg__InferResultsArray__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__msg__infer_results_array__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__msg__infer_results_array__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, msg, InferResultsArray);
  
  int8_t
  _register_msg_type__msg__infer_results_array(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__infer_results_array__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__msg__infer_results_array",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__infer_results_array__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__msg__infer_results_array",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__infer_results_array__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__msg__infer_results_array",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__infer_results_array__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__msg__infer_results_array",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, msg, InferResultsArray),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__msg__infer_results_array",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/msg/detail/evo_sensor_msg__type_support.h"
  #include "deepracer_interfaces_pkg/msg/detail/evo_sensor_msg__struct.h"
  #include "deepracer_interfaces_pkg/msg/detail/evo_sensor_msg__functions.h"
  
  static void * deepracer_interfaces_pkg__msg__evo_sensor_msg__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__msg__EvoSensorMsg__create();
  }
  
  static void deepracer_interfaces_pkg__msg__evo_sensor_msg__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__msg__EvoSensorMsg * ros_message = (deepracer_interfaces_pkg__msg__EvoSensorMsg *)raw_ros_message;
    deepracer_interfaces_pkg__msg__EvoSensorMsg__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__msg__evo_sensor_msg__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__msg__evo_sensor_msg__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, msg, EvoSensorMsg);
  
  int8_t
  _register_msg_type__msg__evo_sensor_msg(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__evo_sensor_msg__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__msg__evo_sensor_msg",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__evo_sensor_msg__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__msg__evo_sensor_msg",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__evo_sensor_msg__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__msg__evo_sensor_msg",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__evo_sensor_msg__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__msg__evo_sensor_msg",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, msg, EvoSensorMsg),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__msg__evo_sensor_msg",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/msg/detail/servo_ctrl_msg__type_support.h"
  #include "deepracer_interfaces_pkg/msg/detail/servo_ctrl_msg__struct.h"
  #include "deepracer_interfaces_pkg/msg/detail/servo_ctrl_msg__functions.h"
  
  static void * deepracer_interfaces_pkg__msg__servo_ctrl_msg__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__msg__ServoCtrlMsg__create();
  }
  
  static void deepracer_interfaces_pkg__msg__servo_ctrl_msg__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__msg__ServoCtrlMsg * ros_message = (deepracer_interfaces_pkg__msg__ServoCtrlMsg *)raw_ros_message;
    deepracer_interfaces_pkg__msg__ServoCtrlMsg__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__msg__servo_ctrl_msg__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__msg__servo_ctrl_msg__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, msg, ServoCtrlMsg);
  
  int8_t
  _register_msg_type__msg__servo_ctrl_msg(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__servo_ctrl_msg__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__msg__servo_ctrl_msg",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__servo_ctrl_msg__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__msg__servo_ctrl_msg",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__servo_ctrl_msg__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__msg__servo_ctrl_msg",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__servo_ctrl_msg__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__msg__servo_ctrl_msg",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, msg, ServoCtrlMsg),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__msg__servo_ctrl_msg",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/msg/detail/network_connection_status__type_support.h"
  #include "deepracer_interfaces_pkg/msg/detail/network_connection_status__struct.h"
  #include "deepracer_interfaces_pkg/msg/detail/network_connection_status__functions.h"
  
  static void * deepracer_interfaces_pkg__msg__network_connection_status__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__msg__NetworkConnectionStatus__create();
  }
  
  static void deepracer_interfaces_pkg__msg__network_connection_status__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__msg__NetworkConnectionStatus * ros_message = (deepracer_interfaces_pkg__msg__NetworkConnectionStatus *)raw_ros_message;
    deepracer_interfaces_pkg__msg__NetworkConnectionStatus__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__msg__network_connection_status__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__msg__network_connection_status__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, msg, NetworkConnectionStatus);
  
  int8_t
  _register_msg_type__msg__network_connection_status(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__network_connection_status__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__msg__network_connection_status",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__network_connection_status__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__msg__network_connection_status",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__network_connection_status__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__msg__network_connection_status",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__network_connection_status__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__msg__network_connection_status",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, msg, NetworkConnectionStatus),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__msg__network_connection_status",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/msg/detail/software_update_pct_msg__type_support.h"
  #include "deepracer_interfaces_pkg/msg/detail/software_update_pct_msg__struct.h"
  #include "deepracer_interfaces_pkg/msg/detail/software_update_pct_msg__functions.h"
  
  static void * deepracer_interfaces_pkg__msg__software_update_pct_msg__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__msg__SoftwareUpdatePctMsg__create();
  }
  
  static void deepracer_interfaces_pkg__msg__software_update_pct_msg__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__msg__SoftwareUpdatePctMsg * ros_message = (deepracer_interfaces_pkg__msg__SoftwareUpdatePctMsg *)raw_ros_message;
    deepracer_interfaces_pkg__msg__SoftwareUpdatePctMsg__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__msg__software_update_pct_msg__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__msg__software_update_pct_msg__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, msg, SoftwareUpdatePctMsg);
  
  int8_t
  _register_msg_type__msg__software_update_pct_msg(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__software_update_pct_msg__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__msg__software_update_pct_msg",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__software_update_pct_msg__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__msg__software_update_pct_msg",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__software_update_pct_msg__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__msg__software_update_pct_msg",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__software_update_pct_msg__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__msg__software_update_pct_msg",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, msg, SoftwareUpdatePctMsg),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__msg__software_update_pct_msg",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/msg/detail/usb_file_system_notification_msg__type_support.h"
  #include "deepracer_interfaces_pkg/msg/detail/usb_file_system_notification_msg__struct.h"
  #include "deepracer_interfaces_pkg/msg/detail/usb_file_system_notification_msg__functions.h"
  
  static void * deepracer_interfaces_pkg__msg__usb_file_system_notification_msg__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__msg__USBFileSystemNotificationMsg__create();
  }
  
  static void deepracer_interfaces_pkg__msg__usb_file_system_notification_msg__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__msg__USBFileSystemNotificationMsg * ros_message = (deepracer_interfaces_pkg__msg__USBFileSystemNotificationMsg *)raw_ros_message;
    deepracer_interfaces_pkg__msg__USBFileSystemNotificationMsg__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__msg__usb_file_system_notification_msg__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__msg__usb_file_system_notification_msg__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, msg, USBFileSystemNotificationMsg);
  
  int8_t
  _register_msg_type__msg__usb_file_system_notification_msg(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__usb_file_system_notification_msg__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__msg__usb_file_system_notification_msg",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__usb_file_system_notification_msg__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__msg__usb_file_system_notification_msg",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__usb_file_system_notification_msg__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__msg__usb_file_system_notification_msg",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__usb_file_system_notification_msg__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__msg__usb_file_system_notification_msg",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, msg, USBFileSystemNotificationMsg),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__msg__usb_file_system_notification_msg",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/msg/detail/detection_delta_msg__type_support.h"
  #include "deepracer_interfaces_pkg/msg/detail/detection_delta_msg__struct.h"
  #include "deepracer_interfaces_pkg/msg/detail/detection_delta_msg__functions.h"
  
  static void * deepracer_interfaces_pkg__msg__detection_delta_msg__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__msg__DetectionDeltaMsg__create();
  }
  
  static void deepracer_interfaces_pkg__msg__detection_delta_msg__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__msg__DetectionDeltaMsg * ros_message = (deepracer_interfaces_pkg__msg__DetectionDeltaMsg *)raw_ros_message;
    deepracer_interfaces_pkg__msg__DetectionDeltaMsg__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__msg__detection_delta_msg__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__msg__detection_delta_msg__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, msg, DetectionDeltaMsg);
  
  int8_t
  _register_msg_type__msg__detection_delta_msg(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__detection_delta_msg__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__msg__detection_delta_msg",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__detection_delta_msg__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__msg__detection_delta_msg",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__detection_delta_msg__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__msg__detection_delta_msg",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__msg__detection_delta_msg__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__msg__detection_delta_msg",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, msg, DetectionDeltaMsg),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__msg__detection_delta_msg",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/active_state_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/active_state_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/active_state_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__active_state_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__ActiveStateSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__active_state_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__ActiveStateSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__ActiveStateSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__ActiveStateSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__active_state_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__active_state_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, ActiveStateSrv_Request);
  
  int8_t
  _register_msg_type__srv__active_state_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__active_state_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__active_state_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__active_state_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__active_state_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__active_state_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__active_state_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__active_state_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__active_state_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, ActiveStateSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__active_state_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/active_state_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/active_state_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/active_state_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__active_state_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__ActiveStateSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__active_state_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__ActiveStateSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__ActiveStateSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__ActiveStateSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__active_state_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__active_state_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, ActiveStateSrv_Response);
  
  int8_t
  _register_msg_type__srv__active_state_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__active_state_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__active_state_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__active_state_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__active_state_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__active_state_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__active_state_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__active_state_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__active_state_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, ActiveStateSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__active_state_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, ActiveStateSrv)();
  
  int8_t
  _register_srv_type__srv__active_state_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, ActiveStateSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__active_state_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/battery_level_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/battery_level_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/battery_level_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__battery_level_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__BatteryLevelSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__battery_level_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__BatteryLevelSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__BatteryLevelSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__BatteryLevelSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__battery_level_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__battery_level_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, BatteryLevelSrv_Request);
  
  int8_t
  _register_msg_type__srv__battery_level_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__battery_level_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__battery_level_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__battery_level_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__battery_level_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__battery_level_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__battery_level_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__battery_level_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__battery_level_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, BatteryLevelSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__battery_level_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/battery_level_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/battery_level_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/battery_level_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__battery_level_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__BatteryLevelSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__battery_level_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__BatteryLevelSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__BatteryLevelSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__BatteryLevelSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__battery_level_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__battery_level_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, BatteryLevelSrv_Response);
  
  int8_t
  _register_msg_type__srv__battery_level_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__battery_level_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__battery_level_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__battery_level_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__battery_level_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__battery_level_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__battery_level_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__battery_level_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__battery_level_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, BatteryLevelSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__battery_level_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, BatteryLevelSrv)();
  
  int8_t
  _register_srv_type__srv__battery_level_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, BatteryLevelSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__battery_level_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/begin_software_update_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/begin_software_update_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/begin_software_update_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__begin_software_update_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__BeginSoftwareUpdateSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__begin_software_update_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__BeginSoftwareUpdateSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__BeginSoftwareUpdateSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__BeginSoftwareUpdateSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__begin_software_update_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__begin_software_update_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, BeginSoftwareUpdateSrv_Request);
  
  int8_t
  _register_msg_type__srv__begin_software_update_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__begin_software_update_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__begin_software_update_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__begin_software_update_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__begin_software_update_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__begin_software_update_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__begin_software_update_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__begin_software_update_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__begin_software_update_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, BeginSoftwareUpdateSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__begin_software_update_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/begin_software_update_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/begin_software_update_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/begin_software_update_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__begin_software_update_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__BeginSoftwareUpdateSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__begin_software_update_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__BeginSoftwareUpdateSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__BeginSoftwareUpdateSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__BeginSoftwareUpdateSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__begin_software_update_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__begin_software_update_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, BeginSoftwareUpdateSrv_Response);
  
  int8_t
  _register_msg_type__srv__begin_software_update_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__begin_software_update_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__begin_software_update_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__begin_software_update_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__begin_software_update_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__begin_software_update_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__begin_software_update_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__begin_software_update_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__begin_software_update_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, BeginSoftwareUpdateSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__begin_software_update_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, BeginSoftwareUpdateSrv)();
  
  int8_t
  _register_srv_type__srv__begin_software_update_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, BeginSoftwareUpdateSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__begin_software_update_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/console_model_action_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/console_model_action_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/console_model_action_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__console_model_action_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__ConsoleModelActionSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__console_model_action_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__ConsoleModelActionSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__ConsoleModelActionSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__ConsoleModelActionSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__console_model_action_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__console_model_action_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, ConsoleModelActionSrv_Request);
  
  int8_t
  _register_msg_type__srv__console_model_action_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__console_model_action_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__console_model_action_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__console_model_action_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__console_model_action_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__console_model_action_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__console_model_action_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__console_model_action_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__console_model_action_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, ConsoleModelActionSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__console_model_action_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/console_model_action_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/console_model_action_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/console_model_action_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__console_model_action_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__ConsoleModelActionSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__console_model_action_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__ConsoleModelActionSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__ConsoleModelActionSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__ConsoleModelActionSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__console_model_action_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__console_model_action_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, ConsoleModelActionSrv_Response);
  
  int8_t
  _register_msg_type__srv__console_model_action_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__console_model_action_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__console_model_action_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__console_model_action_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__console_model_action_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__console_model_action_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__console_model_action_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__console_model_action_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__console_model_action_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, ConsoleModelActionSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__console_model_action_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, ConsoleModelActionSrv)();
  
  int8_t
  _register_srv_type__srv__console_model_action_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, ConsoleModelActionSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__console_model_action_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/enable_state_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/enable_state_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/enable_state_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__enable_state_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__EnableStateSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__enable_state_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__EnableStateSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__EnableStateSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__EnableStateSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__enable_state_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__enable_state_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, EnableStateSrv_Request);
  
  int8_t
  _register_msg_type__srv__enable_state_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__enable_state_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__enable_state_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__enable_state_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__enable_state_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__enable_state_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__enable_state_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__enable_state_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__enable_state_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, EnableStateSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__enable_state_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/enable_state_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/enable_state_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/enable_state_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__enable_state_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__EnableStateSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__enable_state_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__EnableStateSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__EnableStateSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__EnableStateSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__enable_state_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__enable_state_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, EnableStateSrv_Response);
  
  int8_t
  _register_msg_type__srv__enable_state_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__enable_state_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__enable_state_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__enable_state_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__enable_state_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__enable_state_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__enable_state_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__enable_state_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__enable_state_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, EnableStateSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__enable_state_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, EnableStateSrv)();
  
  int8_t
  _register_srv_type__srv__enable_state_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, EnableStateSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__enable_state_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/get_calibration_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/get_calibration_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/get_calibration_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__get_calibration_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__GetCalibrationSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__get_calibration_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__GetCalibrationSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__GetCalibrationSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__GetCalibrationSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__get_calibration_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__get_calibration_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, GetCalibrationSrv_Request);
  
  int8_t
  _register_msg_type__srv__get_calibration_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_calibration_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__get_calibration_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_calibration_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__get_calibration_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_calibration_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__get_calibration_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_calibration_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__get_calibration_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, GetCalibrationSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__get_calibration_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/get_calibration_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/get_calibration_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/get_calibration_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__get_calibration_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__GetCalibrationSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__get_calibration_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__GetCalibrationSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__GetCalibrationSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__GetCalibrationSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__get_calibration_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__get_calibration_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, GetCalibrationSrv_Response);
  
  int8_t
  _register_msg_type__srv__get_calibration_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_calibration_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__get_calibration_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_calibration_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__get_calibration_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_calibration_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__get_calibration_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_calibration_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__get_calibration_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, GetCalibrationSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__get_calibration_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, GetCalibrationSrv)();
  
  int8_t
  _register_srv_type__srv__get_calibration_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, GetCalibrationSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__get_calibration_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/get_device_info_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/get_device_info_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/get_device_info_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__get_device_info_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__GetDeviceInfoSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__get_device_info_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__GetDeviceInfoSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__GetDeviceInfoSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__GetDeviceInfoSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__get_device_info_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__get_device_info_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, GetDeviceInfoSrv_Request);
  
  int8_t
  _register_msg_type__srv__get_device_info_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_device_info_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__get_device_info_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_device_info_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__get_device_info_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_device_info_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__get_device_info_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_device_info_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__get_device_info_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, GetDeviceInfoSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__get_device_info_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/get_device_info_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/get_device_info_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/get_device_info_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__get_device_info_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__GetDeviceInfoSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__get_device_info_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__GetDeviceInfoSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__GetDeviceInfoSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__GetDeviceInfoSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__get_device_info_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__get_device_info_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, GetDeviceInfoSrv_Response);
  
  int8_t
  _register_msg_type__srv__get_device_info_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_device_info_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__get_device_info_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_device_info_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__get_device_info_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_device_info_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__get_device_info_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_device_info_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__get_device_info_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, GetDeviceInfoSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__get_device_info_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, GetDeviceInfoSrv)();
  
  int8_t
  _register_srv_type__srv__get_device_info_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, GetDeviceInfoSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__get_device_info_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/get_led_ctrl_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/get_led_ctrl_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/get_led_ctrl_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__get_led_ctrl_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__GetLedCtrlSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__get_led_ctrl_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__GetLedCtrlSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__GetLedCtrlSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__GetLedCtrlSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__get_led_ctrl_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__get_led_ctrl_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, GetLedCtrlSrv_Request);
  
  int8_t
  _register_msg_type__srv__get_led_ctrl_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_led_ctrl_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__get_led_ctrl_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_led_ctrl_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__get_led_ctrl_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_led_ctrl_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__get_led_ctrl_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_led_ctrl_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__get_led_ctrl_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, GetLedCtrlSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__get_led_ctrl_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/get_led_ctrl_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/get_led_ctrl_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/get_led_ctrl_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__get_led_ctrl_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__GetLedCtrlSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__get_led_ctrl_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__GetLedCtrlSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__GetLedCtrlSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__GetLedCtrlSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__get_led_ctrl_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__get_led_ctrl_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, GetLedCtrlSrv_Response);
  
  int8_t
  _register_msg_type__srv__get_led_ctrl_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_led_ctrl_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__get_led_ctrl_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_led_ctrl_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__get_led_ctrl_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_led_ctrl_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__get_led_ctrl_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_led_ctrl_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__get_led_ctrl_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, GetLedCtrlSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__get_led_ctrl_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, GetLedCtrlSrv)();
  
  int8_t
  _register_srv_type__srv__get_led_ctrl_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, GetLedCtrlSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__get_led_ctrl_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/get_model_loading_status_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/get_model_loading_status_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/get_model_loading_status_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__get_model_loading_status_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__GetModelLoadingStatusSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__get_model_loading_status_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__GetModelLoadingStatusSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__GetModelLoadingStatusSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__GetModelLoadingStatusSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__get_model_loading_status_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__get_model_loading_status_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, GetModelLoadingStatusSrv_Request);
  
  int8_t
  _register_msg_type__srv__get_model_loading_status_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_model_loading_status_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__get_model_loading_status_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_model_loading_status_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__get_model_loading_status_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_model_loading_status_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__get_model_loading_status_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_model_loading_status_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__get_model_loading_status_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, GetModelLoadingStatusSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__get_model_loading_status_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/get_model_loading_status_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/get_model_loading_status_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/get_model_loading_status_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__get_model_loading_status_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__GetModelLoadingStatusSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__get_model_loading_status_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__GetModelLoadingStatusSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__GetModelLoadingStatusSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__GetModelLoadingStatusSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__get_model_loading_status_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__get_model_loading_status_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, GetModelLoadingStatusSrv_Response);
  
  int8_t
  _register_msg_type__srv__get_model_loading_status_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_model_loading_status_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__get_model_loading_status_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_model_loading_status_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__get_model_loading_status_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_model_loading_status_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__get_model_loading_status_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_model_loading_status_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__get_model_loading_status_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, GetModelLoadingStatusSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__get_model_loading_status_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, GetModelLoadingStatusSrv)();
  
  int8_t
  _register_srv_type__srv__get_model_loading_status_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, GetModelLoadingStatusSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__get_model_loading_status_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/inference_state_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/inference_state_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/inference_state_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__inference_state_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__InferenceStateSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__inference_state_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__InferenceStateSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__InferenceStateSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__InferenceStateSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__inference_state_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__inference_state_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, InferenceStateSrv_Request);
  
  int8_t
  _register_msg_type__srv__inference_state_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__inference_state_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__inference_state_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__inference_state_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__inference_state_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__inference_state_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__inference_state_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__inference_state_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__inference_state_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, InferenceStateSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__inference_state_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/inference_state_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/inference_state_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/inference_state_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__inference_state_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__InferenceStateSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__inference_state_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__InferenceStateSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__InferenceStateSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__InferenceStateSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__inference_state_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__inference_state_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, InferenceStateSrv_Response);
  
  int8_t
  _register_msg_type__srv__inference_state_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__inference_state_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__inference_state_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__inference_state_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__inference_state_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__inference_state_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__inference_state_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__inference_state_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__inference_state_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, InferenceStateSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__inference_state_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, InferenceStateSrv)();
  
  int8_t
  _register_srv_type__srv__inference_state_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, InferenceStateSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__inference_state_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/lidar_config_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/lidar_config_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/lidar_config_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__lidar_config_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__LidarConfigSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__lidar_config_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__LidarConfigSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__LidarConfigSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__LidarConfigSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__lidar_config_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__lidar_config_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, LidarConfigSrv_Request);
  
  int8_t
  _register_msg_type__srv__lidar_config_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__lidar_config_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__lidar_config_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__lidar_config_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__lidar_config_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__lidar_config_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__lidar_config_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__lidar_config_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__lidar_config_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, LidarConfigSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__lidar_config_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/lidar_config_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/lidar_config_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/lidar_config_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__lidar_config_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__LidarConfigSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__lidar_config_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__LidarConfigSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__LidarConfigSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__LidarConfigSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__lidar_config_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__lidar_config_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, LidarConfigSrv_Response);
  
  int8_t
  _register_msg_type__srv__lidar_config_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__lidar_config_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__lidar_config_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__lidar_config_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__lidar_config_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__lidar_config_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__lidar_config_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__lidar_config_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__lidar_config_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, LidarConfigSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__lidar_config_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, LidarConfigSrv)();
  
  int8_t
  _register_srv_type__srv__lidar_config_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, LidarConfigSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__lidar_config_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/load_model_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/load_model_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/load_model_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__load_model_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__LoadModelSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__load_model_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__LoadModelSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__LoadModelSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__LoadModelSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__load_model_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__load_model_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, LoadModelSrv_Request);
  
  int8_t
  _register_msg_type__srv__load_model_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__load_model_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__load_model_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__load_model_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__load_model_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__load_model_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__load_model_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__load_model_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__load_model_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, LoadModelSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__load_model_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/load_model_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/load_model_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/load_model_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__load_model_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__LoadModelSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__load_model_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__LoadModelSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__LoadModelSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__LoadModelSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__load_model_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__load_model_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, LoadModelSrv_Response);
  
  int8_t
  _register_msg_type__srv__load_model_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__load_model_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__load_model_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__load_model_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__load_model_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__load_model_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__load_model_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__load_model_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__load_model_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, LoadModelSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__load_model_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, LoadModelSrv)();
  
  int8_t
  _register_srv_type__srv__load_model_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, LoadModelSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__load_model_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/model_optimize_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/model_optimize_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/model_optimize_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__model_optimize_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__ModelOptimizeSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__model_optimize_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__ModelOptimizeSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__ModelOptimizeSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__ModelOptimizeSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__model_optimize_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__model_optimize_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, ModelOptimizeSrv_Request);
  
  int8_t
  _register_msg_type__srv__model_optimize_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__model_optimize_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__model_optimize_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__model_optimize_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__model_optimize_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__model_optimize_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__model_optimize_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__model_optimize_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__model_optimize_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, ModelOptimizeSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__model_optimize_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/model_optimize_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/model_optimize_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/model_optimize_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__model_optimize_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__ModelOptimizeSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__model_optimize_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__ModelOptimizeSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__ModelOptimizeSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__ModelOptimizeSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__model_optimize_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__model_optimize_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, ModelOptimizeSrv_Response);
  
  int8_t
  _register_msg_type__srv__model_optimize_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__model_optimize_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__model_optimize_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__model_optimize_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__model_optimize_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__model_optimize_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__model_optimize_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__model_optimize_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__model_optimize_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, ModelOptimizeSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__model_optimize_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, ModelOptimizeSrv)();
  
  int8_t
  _register_srv_type__srv__model_optimize_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, ModelOptimizeSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__model_optimize_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/model_state_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/model_state_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/model_state_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__model_state_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__ModelStateSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__model_state_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__ModelStateSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__ModelStateSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__ModelStateSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__model_state_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__model_state_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, ModelStateSrv_Request);
  
  int8_t
  _register_msg_type__srv__model_state_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__model_state_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__model_state_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__model_state_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__model_state_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__model_state_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__model_state_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__model_state_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__model_state_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, ModelStateSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__model_state_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/model_state_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/model_state_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/model_state_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__model_state_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__ModelStateSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__model_state_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__ModelStateSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__ModelStateSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__ModelStateSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__model_state_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__model_state_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, ModelStateSrv_Response);
  
  int8_t
  _register_msg_type__srv__model_state_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__model_state_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__model_state_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__model_state_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__model_state_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__model_state_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__model_state_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__model_state_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__model_state_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, ModelStateSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__model_state_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, ModelStateSrv)();
  
  int8_t
  _register_srv_type__srv__model_state_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, ModelStateSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__model_state_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/nav_throttle_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/nav_throttle_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/nav_throttle_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__nav_throttle_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__NavThrottleSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__nav_throttle_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__NavThrottleSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__NavThrottleSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__NavThrottleSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__nav_throttle_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__nav_throttle_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, NavThrottleSrv_Request);
  
  int8_t
  _register_msg_type__srv__nav_throttle_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__nav_throttle_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__nav_throttle_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__nav_throttle_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__nav_throttle_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__nav_throttle_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__nav_throttle_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__nav_throttle_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__nav_throttle_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, NavThrottleSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__nav_throttle_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/nav_throttle_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/nav_throttle_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/nav_throttle_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__nav_throttle_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__NavThrottleSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__nav_throttle_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__NavThrottleSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__NavThrottleSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__NavThrottleSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__nav_throttle_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__nav_throttle_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, NavThrottleSrv_Response);
  
  int8_t
  _register_msg_type__srv__nav_throttle_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__nav_throttle_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__nav_throttle_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__nav_throttle_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__nav_throttle_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__nav_throttle_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__nav_throttle_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__nav_throttle_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__nav_throttle_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, NavThrottleSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__nav_throttle_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, NavThrottleSrv)();
  
  int8_t
  _register_srv_type__srv__nav_throttle_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, NavThrottleSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__nav_throttle_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/otg_link_state_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/otg_link_state_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/otg_link_state_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__otg_link_state_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__OTGLinkStateSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__otg_link_state_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__OTGLinkStateSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__OTGLinkStateSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__OTGLinkStateSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__otg_link_state_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__otg_link_state_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, OTGLinkStateSrv_Request);
  
  int8_t
  _register_msg_type__srv__otg_link_state_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__otg_link_state_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__otg_link_state_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__otg_link_state_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__otg_link_state_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__otg_link_state_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__otg_link_state_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__otg_link_state_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__otg_link_state_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, OTGLinkStateSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__otg_link_state_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/otg_link_state_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/otg_link_state_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/otg_link_state_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__otg_link_state_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__OTGLinkStateSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__otg_link_state_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__OTGLinkStateSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__OTGLinkStateSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__OTGLinkStateSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__otg_link_state_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__otg_link_state_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, OTGLinkStateSrv_Response);
  
  int8_t
  _register_msg_type__srv__otg_link_state_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__otg_link_state_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__otg_link_state_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__otg_link_state_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__otg_link_state_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__otg_link_state_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__otg_link_state_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__otg_link_state_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__otg_link_state_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, OTGLinkStateSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__otg_link_state_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, OTGLinkStateSrv)();
  
  int8_t
  _register_srv_type__srv__otg_link_state_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, OTGLinkStateSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__otg_link_state_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/sensor_status_check_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/sensor_status_check_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/sensor_status_check_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__sensor_status_check_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__SensorStatusCheckSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__sensor_status_check_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__SensorStatusCheckSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__SensorStatusCheckSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__SensorStatusCheckSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__sensor_status_check_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__sensor_status_check_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SensorStatusCheckSrv_Request);
  
  int8_t
  _register_msg_type__srv__sensor_status_check_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__sensor_status_check_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__sensor_status_check_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__sensor_status_check_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__sensor_status_check_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__sensor_status_check_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__sensor_status_check_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__sensor_status_check_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__sensor_status_check_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SensorStatusCheckSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__sensor_status_check_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/sensor_status_check_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/sensor_status_check_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/sensor_status_check_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__sensor_status_check_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__SensorStatusCheckSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__sensor_status_check_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__SensorStatusCheckSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__SensorStatusCheckSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__SensorStatusCheckSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__sensor_status_check_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__sensor_status_check_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SensorStatusCheckSrv_Response);
  
  int8_t
  _register_msg_type__srv__sensor_status_check_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__sensor_status_check_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__sensor_status_check_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__sensor_status_check_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__sensor_status_check_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__sensor_status_check_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__sensor_status_check_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__sensor_status_check_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__sensor_status_check_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SensorStatusCheckSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__sensor_status_check_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, SensorStatusCheckSrv)();
  
  int8_t
  _register_srv_type__srv__sensor_status_check_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, SensorStatusCheckSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__sensor_status_check_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/set_calibration_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/set_calibration_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/set_calibration_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__set_calibration_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__SetCalibrationSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__set_calibration_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__SetCalibrationSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__SetCalibrationSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__SetCalibrationSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__set_calibration_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__set_calibration_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SetCalibrationSrv_Request);
  
  int8_t
  _register_msg_type__srv__set_calibration_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_calibration_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__set_calibration_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_calibration_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__set_calibration_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_calibration_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__set_calibration_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_calibration_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__set_calibration_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SetCalibrationSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__set_calibration_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/set_calibration_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/set_calibration_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/set_calibration_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__set_calibration_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__SetCalibrationSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__set_calibration_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__SetCalibrationSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__SetCalibrationSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__SetCalibrationSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__set_calibration_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__set_calibration_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SetCalibrationSrv_Response);
  
  int8_t
  _register_msg_type__srv__set_calibration_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_calibration_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__set_calibration_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_calibration_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__set_calibration_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_calibration_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__set_calibration_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_calibration_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__set_calibration_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SetCalibrationSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__set_calibration_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, SetCalibrationSrv)();
  
  int8_t
  _register_srv_type__srv__set_calibration_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, SetCalibrationSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__set_calibration_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/servo_gpio_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/servo_gpio_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/servo_gpio_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__servo_gpio_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__ServoGPIOSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__servo_gpio_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__ServoGPIOSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__ServoGPIOSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__ServoGPIOSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__servo_gpio_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__servo_gpio_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, ServoGPIOSrv_Request);
  
  int8_t
  _register_msg_type__srv__servo_gpio_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__servo_gpio_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__servo_gpio_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__servo_gpio_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__servo_gpio_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__servo_gpio_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__servo_gpio_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__servo_gpio_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__servo_gpio_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, ServoGPIOSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__servo_gpio_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/servo_gpio_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/servo_gpio_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/servo_gpio_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__servo_gpio_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__ServoGPIOSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__servo_gpio_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__ServoGPIOSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__ServoGPIOSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__ServoGPIOSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__servo_gpio_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__servo_gpio_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, ServoGPIOSrv_Response);
  
  int8_t
  _register_msg_type__srv__servo_gpio_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__servo_gpio_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__servo_gpio_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__servo_gpio_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__servo_gpio_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__servo_gpio_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__servo_gpio_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__servo_gpio_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__servo_gpio_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, ServoGPIOSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__servo_gpio_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, ServoGPIOSrv)();
  
  int8_t
  _register_srv_type__srv__servo_gpio_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, ServoGPIOSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__servo_gpio_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/set_led_ctrl_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/set_led_ctrl_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/set_led_ctrl_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__set_led_ctrl_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__SetLedCtrlSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__set_led_ctrl_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__SetLedCtrlSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__SetLedCtrlSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__SetLedCtrlSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__set_led_ctrl_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__set_led_ctrl_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SetLedCtrlSrv_Request);
  
  int8_t
  _register_msg_type__srv__set_led_ctrl_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_led_ctrl_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__set_led_ctrl_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_led_ctrl_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__set_led_ctrl_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_led_ctrl_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__set_led_ctrl_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_led_ctrl_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__set_led_ctrl_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SetLedCtrlSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__set_led_ctrl_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/set_led_ctrl_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/set_led_ctrl_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/set_led_ctrl_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__set_led_ctrl_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__SetLedCtrlSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__set_led_ctrl_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__SetLedCtrlSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__SetLedCtrlSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__SetLedCtrlSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__set_led_ctrl_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__set_led_ctrl_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SetLedCtrlSrv_Response);
  
  int8_t
  _register_msg_type__srv__set_led_ctrl_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_led_ctrl_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__set_led_ctrl_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_led_ctrl_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__set_led_ctrl_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_led_ctrl_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__set_led_ctrl_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_led_ctrl_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__set_led_ctrl_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SetLedCtrlSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__set_led_ctrl_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, SetLedCtrlSrv)();
  
  int8_t
  _register_srv_type__srv__set_led_ctrl_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, SetLedCtrlSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__set_led_ctrl_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/set_max_speed_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/set_max_speed_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/set_max_speed_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__set_max_speed_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__SetMaxSpeedSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__set_max_speed_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__SetMaxSpeedSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__SetMaxSpeedSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__SetMaxSpeedSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__set_max_speed_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__set_max_speed_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SetMaxSpeedSrv_Request);
  
  int8_t
  _register_msg_type__srv__set_max_speed_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_max_speed_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__set_max_speed_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_max_speed_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__set_max_speed_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_max_speed_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__set_max_speed_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_max_speed_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__set_max_speed_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SetMaxSpeedSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__set_max_speed_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/set_max_speed_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/set_max_speed_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/set_max_speed_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__set_max_speed_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__SetMaxSpeedSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__set_max_speed_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__SetMaxSpeedSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__SetMaxSpeedSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__SetMaxSpeedSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__set_max_speed_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__set_max_speed_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SetMaxSpeedSrv_Response);
  
  int8_t
  _register_msg_type__srv__set_max_speed_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_max_speed_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__set_max_speed_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_max_speed_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__set_max_speed_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_max_speed_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__set_max_speed_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_max_speed_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__set_max_speed_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SetMaxSpeedSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__set_max_speed_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, SetMaxSpeedSrv)();
  
  int8_t
  _register_srv_type__srv__set_max_speed_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, SetMaxSpeedSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__set_max_speed_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/set_status_led_blink_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/set_status_led_blink_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/set_status_led_blink_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__set_status_led_blink_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__SetStatusLedBlinkSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__set_status_led_blink_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__SetStatusLedBlinkSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__SetStatusLedBlinkSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__SetStatusLedBlinkSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__set_status_led_blink_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__set_status_led_blink_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SetStatusLedBlinkSrv_Request);
  
  int8_t
  _register_msg_type__srv__set_status_led_blink_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_status_led_blink_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__set_status_led_blink_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_status_led_blink_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__set_status_led_blink_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_status_led_blink_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__set_status_led_blink_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_status_led_blink_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__set_status_led_blink_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SetStatusLedBlinkSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__set_status_led_blink_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/set_status_led_blink_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/set_status_led_blink_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/set_status_led_blink_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__set_status_led_blink_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__SetStatusLedBlinkSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__set_status_led_blink_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__SetStatusLedBlinkSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__SetStatusLedBlinkSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__SetStatusLedBlinkSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__set_status_led_blink_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__set_status_led_blink_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SetStatusLedBlinkSrv_Response);
  
  int8_t
  _register_msg_type__srv__set_status_led_blink_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_status_led_blink_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__set_status_led_blink_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_status_led_blink_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__set_status_led_blink_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_status_led_blink_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__set_status_led_blink_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_status_led_blink_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__set_status_led_blink_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SetStatusLedBlinkSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__set_status_led_blink_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, SetStatusLedBlinkSrv)();
  
  int8_t
  _register_srv_type__srv__set_status_led_blink_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, SetStatusLedBlinkSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__set_status_led_blink_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/set_status_led_solid_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/set_status_led_solid_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/set_status_led_solid_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__set_status_led_solid_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__SetStatusLedSolidSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__set_status_led_solid_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__SetStatusLedSolidSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__SetStatusLedSolidSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__SetStatusLedSolidSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__set_status_led_solid_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__set_status_led_solid_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SetStatusLedSolidSrv_Request);
  
  int8_t
  _register_msg_type__srv__set_status_led_solid_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_status_led_solid_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__set_status_led_solid_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_status_led_solid_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__set_status_led_solid_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_status_led_solid_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__set_status_led_solid_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_status_led_solid_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__set_status_led_solid_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SetStatusLedSolidSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__set_status_led_solid_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/set_status_led_solid_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/set_status_led_solid_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/set_status_led_solid_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__set_status_led_solid_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__SetStatusLedSolidSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__set_status_led_solid_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__SetStatusLedSolidSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__SetStatusLedSolidSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__SetStatusLedSolidSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__set_status_led_solid_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__set_status_led_solid_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SetStatusLedSolidSrv_Response);
  
  int8_t
  _register_msg_type__srv__set_status_led_solid_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_status_led_solid_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__set_status_led_solid_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_status_led_solid_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__set_status_led_solid_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_status_led_solid_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__set_status_led_solid_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__set_status_led_solid_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__set_status_led_solid_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SetStatusLedSolidSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__set_status_led_solid_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, SetStatusLedSolidSrv)();
  
  int8_t
  _register_srv_type__srv__set_status_led_solid_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, SetStatusLedSolidSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__set_status_led_solid_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/software_update_check_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/software_update_check_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/software_update_check_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__software_update_check_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__SoftwareUpdateCheckSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__software_update_check_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__SoftwareUpdateCheckSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__SoftwareUpdateCheckSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__SoftwareUpdateCheckSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__software_update_check_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__software_update_check_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SoftwareUpdateCheckSrv_Request);
  
  int8_t
  _register_msg_type__srv__software_update_check_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__software_update_check_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__software_update_check_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__software_update_check_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__software_update_check_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__software_update_check_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__software_update_check_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__software_update_check_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__software_update_check_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SoftwareUpdateCheckSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__software_update_check_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/software_update_check_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/software_update_check_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/software_update_check_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__software_update_check_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__SoftwareUpdateCheckSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__software_update_check_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__SoftwareUpdateCheckSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__SoftwareUpdateCheckSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__SoftwareUpdateCheckSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__software_update_check_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__software_update_check_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SoftwareUpdateCheckSrv_Response);
  
  int8_t
  _register_msg_type__srv__software_update_check_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__software_update_check_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__software_update_check_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__software_update_check_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__software_update_check_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__software_update_check_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__software_update_check_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__software_update_check_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__software_update_check_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SoftwareUpdateCheckSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__software_update_check_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, SoftwareUpdateCheckSrv)();
  
  int8_t
  _register_srv_type__srv__software_update_check_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, SoftwareUpdateCheckSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__software_update_check_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/software_update_state_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/software_update_state_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/software_update_state_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__software_update_state_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__SoftwareUpdateStateSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__software_update_state_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__SoftwareUpdateStateSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__SoftwareUpdateStateSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__SoftwareUpdateStateSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__software_update_state_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__software_update_state_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SoftwareUpdateStateSrv_Request);
  
  int8_t
  _register_msg_type__srv__software_update_state_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__software_update_state_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__software_update_state_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__software_update_state_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__software_update_state_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__software_update_state_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__software_update_state_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__software_update_state_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__software_update_state_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SoftwareUpdateStateSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__software_update_state_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/software_update_state_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/software_update_state_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/software_update_state_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__software_update_state_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__SoftwareUpdateStateSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__software_update_state_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__SoftwareUpdateStateSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__SoftwareUpdateStateSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__SoftwareUpdateStateSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__software_update_state_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__software_update_state_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SoftwareUpdateStateSrv_Response);
  
  int8_t
  _register_msg_type__srv__software_update_state_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__software_update_state_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__software_update_state_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__software_update_state_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__software_update_state_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__software_update_state_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__software_update_state_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__software_update_state_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__software_update_state_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, SoftwareUpdateStateSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__software_update_state_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, SoftwareUpdateStateSrv)();
  
  int8_t
  _register_srv_type__srv__software_update_state_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, SoftwareUpdateStateSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__software_update_state_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/usb_file_system_subscribe_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/usb_file_system_subscribe_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/usb_file_system_subscribe_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__usb_file_system_subscribe_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__USBFileSystemSubscribeSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__usb_file_system_subscribe_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__USBFileSystemSubscribeSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__USBFileSystemSubscribeSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__USBFileSystemSubscribeSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__usb_file_system_subscribe_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__usb_file_system_subscribe_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, USBFileSystemSubscribeSrv_Request);
  
  int8_t
  _register_msg_type__srv__usb_file_system_subscribe_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__usb_file_system_subscribe_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__usb_file_system_subscribe_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__usb_file_system_subscribe_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__usb_file_system_subscribe_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__usb_file_system_subscribe_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__usb_file_system_subscribe_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__usb_file_system_subscribe_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__usb_file_system_subscribe_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, USBFileSystemSubscribeSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__usb_file_system_subscribe_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/usb_file_system_subscribe_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/usb_file_system_subscribe_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/usb_file_system_subscribe_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__usb_file_system_subscribe_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__USBFileSystemSubscribeSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__usb_file_system_subscribe_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__USBFileSystemSubscribeSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__USBFileSystemSubscribeSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__USBFileSystemSubscribeSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__usb_file_system_subscribe_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__usb_file_system_subscribe_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, USBFileSystemSubscribeSrv_Response);
  
  int8_t
  _register_msg_type__srv__usb_file_system_subscribe_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__usb_file_system_subscribe_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__usb_file_system_subscribe_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__usb_file_system_subscribe_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__usb_file_system_subscribe_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__usb_file_system_subscribe_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__usb_file_system_subscribe_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__usb_file_system_subscribe_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__usb_file_system_subscribe_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, USBFileSystemSubscribeSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__usb_file_system_subscribe_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, USBFileSystemSubscribeSrv)();
  
  int8_t
  _register_srv_type__srv__usb_file_system_subscribe_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, USBFileSystemSubscribeSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__usb_file_system_subscribe_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/usb_mount_point_manager_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/usb_mount_point_manager_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/usb_mount_point_manager_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__usb_mount_point_manager_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__USBMountPointManagerSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__usb_mount_point_manager_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__USBMountPointManagerSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__USBMountPointManagerSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__USBMountPointManagerSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__usb_mount_point_manager_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__usb_mount_point_manager_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, USBMountPointManagerSrv_Request);
  
  int8_t
  _register_msg_type__srv__usb_mount_point_manager_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__usb_mount_point_manager_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__usb_mount_point_manager_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__usb_mount_point_manager_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__usb_mount_point_manager_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__usb_mount_point_manager_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__usb_mount_point_manager_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__usb_mount_point_manager_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__usb_mount_point_manager_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, USBMountPointManagerSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__usb_mount_point_manager_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/usb_mount_point_manager_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/usb_mount_point_manager_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/usb_mount_point_manager_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__usb_mount_point_manager_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__USBMountPointManagerSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__usb_mount_point_manager_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__USBMountPointManagerSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__USBMountPointManagerSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__USBMountPointManagerSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__usb_mount_point_manager_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__usb_mount_point_manager_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, USBMountPointManagerSrv_Response);
  
  int8_t
  _register_msg_type__srv__usb_mount_point_manager_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__usb_mount_point_manager_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__usb_mount_point_manager_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__usb_mount_point_manager_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__usb_mount_point_manager_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__usb_mount_point_manager_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__usb_mount_point_manager_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__usb_mount_point_manager_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__usb_mount_point_manager_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, USBMountPointManagerSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__usb_mount_point_manager_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, USBMountPointManagerSrv)();
  
  int8_t
  _register_srv_type__srv__usb_mount_point_manager_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, USBMountPointManagerSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__usb_mount_point_manager_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/verify_model_ready_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/verify_model_ready_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/verify_model_ready_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__verify_model_ready_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__VerifyModelReadySrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__verify_model_ready_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__VerifyModelReadySrv_Request * ros_message = (deepracer_interfaces_pkg__srv__VerifyModelReadySrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__VerifyModelReadySrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__verify_model_ready_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__verify_model_ready_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, VerifyModelReadySrv_Request);
  
  int8_t
  _register_msg_type__srv__verify_model_ready_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__verify_model_ready_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__verify_model_ready_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__verify_model_ready_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__verify_model_ready_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__verify_model_ready_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__verify_model_ready_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__verify_model_ready_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__verify_model_ready_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, VerifyModelReadySrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__verify_model_ready_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/verify_model_ready_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/verify_model_ready_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/verify_model_ready_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__verify_model_ready_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__VerifyModelReadySrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__verify_model_ready_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__VerifyModelReadySrv_Response * ros_message = (deepracer_interfaces_pkg__srv__VerifyModelReadySrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__VerifyModelReadySrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__verify_model_ready_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__verify_model_ready_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, VerifyModelReadySrv_Response);
  
  int8_t
  _register_msg_type__srv__verify_model_ready_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__verify_model_ready_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__verify_model_ready_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__verify_model_ready_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__verify_model_ready_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__verify_model_ready_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__verify_model_ready_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__verify_model_ready_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__verify_model_ready_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, VerifyModelReadySrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__verify_model_ready_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, VerifyModelReadySrv)();
  
  int8_t
  _register_srv_type__srv__verify_model_ready_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, VerifyModelReadySrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__verify_model_ready_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/video_state_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/video_state_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/video_state_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__video_state_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__VideoStateSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__video_state_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__VideoStateSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__VideoStateSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__VideoStateSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__video_state_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__video_state_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, VideoStateSrv_Request);
  
  int8_t
  _register_msg_type__srv__video_state_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__video_state_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__video_state_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__video_state_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__video_state_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__video_state_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__video_state_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__video_state_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__video_state_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, VideoStateSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__video_state_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/video_state_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/video_state_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/video_state_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__video_state_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__VideoStateSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__video_state_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__VideoStateSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__VideoStateSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__VideoStateSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__video_state_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__video_state_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, VideoStateSrv_Response);
  
  int8_t
  _register_msg_type__srv__video_state_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__video_state_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__video_state_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__video_state_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__video_state_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__video_state_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__video_state_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__video_state_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__video_state_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, VideoStateSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__video_state_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, VideoStateSrv)();
  
  int8_t
  _register_srv_type__srv__video_state_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, VideoStateSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__video_state_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/get_ctrl_modes_srv__type_support.h"
  #include "deepracer_interfaces_pkg/srv/detail/get_ctrl_modes_srv__struct.h"
  #include "deepracer_interfaces_pkg/srv/detail/get_ctrl_modes_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__get_ctrl_modes_srv__request__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__GetCtrlModesSrv_Request__create();
  }
  
  static void deepracer_interfaces_pkg__srv__get_ctrl_modes_srv__request__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__GetCtrlModesSrv_Request * ros_message = (deepracer_interfaces_pkg__srv__GetCtrlModesSrv_Request *)raw_ros_message;
    deepracer_interfaces_pkg__srv__GetCtrlModesSrv_Request__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__get_ctrl_modes_srv__request__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__get_ctrl_modes_srv__request__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, GetCtrlModesSrv_Request);
  
  int8_t
  _register_msg_type__srv__get_ctrl_modes_srv__request(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_ctrl_modes_srv__request__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__get_ctrl_modes_srv__request",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_ctrl_modes_srv__request__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__get_ctrl_modes_srv__request",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_ctrl_modes_srv__request__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__get_ctrl_modes_srv__request",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_ctrl_modes_srv__request__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__get_ctrl_modes_srv__request",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, GetCtrlModesSrv_Request),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__get_ctrl_modes_srv__request",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  // already included above
  // #include <stdbool.h>
  // already included above
  // #include <stdint.h>
  // already included above
  // #include "rosidl_runtime_c/visibility_control.h"
  // already included above
  // #include "rosidl_runtime_c/message_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/service_type_support_struct.h"
  // already included above
  // #include "rosidl_runtime_c/action_type_support_struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/get_ctrl_modes_srv__type_support.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/get_ctrl_modes_srv__struct.h"
  // already included above
  // #include "deepracer_interfaces_pkg/srv/detail/get_ctrl_modes_srv__functions.h"
  
  static void * deepracer_interfaces_pkg__srv__get_ctrl_modes_srv__response__create_ros_message(void)
  {
    return deepracer_interfaces_pkg__srv__GetCtrlModesSrv_Response__create();
  }
  
  static void deepracer_interfaces_pkg__srv__get_ctrl_modes_srv__response__destroy_ros_message(void * raw_ros_message)
  {
    deepracer_interfaces_pkg__srv__GetCtrlModesSrv_Response * ros_message = (deepracer_interfaces_pkg__srv__GetCtrlModesSrv_Response *)raw_ros_message;
    deepracer_interfaces_pkg__srv__GetCtrlModesSrv_Response__destroy(ros_message);
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  bool deepracer_interfaces_pkg__srv__get_ctrl_modes_srv__response__convert_from_py(PyObject * _pymsg, void * ros_message);
  ROSIDL_GENERATOR_C_IMPORT
  PyObject * deepracer_interfaces_pkg__srv__get_ctrl_modes_srv__response__convert_to_py(void * raw_ros_message);
  
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_message_type_support_t *
  ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, GetCtrlModesSrv_Response);
  
  int8_t
  _register_msg_type__srv__get_ctrl_modes_srv__response(PyObject * pymodule)
  {
    int8_t err;
  
    PyObject * pyobject_create_ros_message = NULL;
    pyobject_create_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_ctrl_modes_srv__response__create_ros_message,
      NULL, NULL);
    if (!pyobject_create_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "create_ros_message_msg__srv__get_ctrl_modes_srv__response",
      pyobject_create_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_create_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_destroy_ros_message = NULL;
    pyobject_destroy_ros_message = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_ctrl_modes_srv__response__destroy_ros_message,
      NULL, NULL);
    if (!pyobject_destroy_ros_message) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "destroy_ros_message_msg__srv__get_ctrl_modes_srv__response",
      pyobject_destroy_ros_message);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_destroy_ros_message);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_from_py = NULL;
    pyobject_convert_from_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_ctrl_modes_srv__response__convert_from_py,
      NULL, NULL);
    if (!pyobject_convert_from_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_from_py_msg__srv__get_ctrl_modes_srv__response",
      pyobject_convert_from_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_from_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_convert_to_py = NULL;
    pyobject_convert_to_py = PyCapsule_New(
      (void *)&deepracer_interfaces_pkg__srv__get_ctrl_modes_srv__response__convert_to_py,
      NULL, NULL);
    if (!pyobject_convert_to_py) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "convert_to_py_msg__srv__get_ctrl_modes_srv__response",
      pyobject_convert_to_py);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_convert_to_py);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
  
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(deepracer_interfaces_pkg, srv, GetCtrlModesSrv_Response),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_msg__srv__get_ctrl_modes_srv__response",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  ROSIDL_GENERATOR_C_IMPORT
  const rosidl_service_type_support_t *
  ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, GetCtrlModesSrv)();
  
  int8_t
  _register_srv_type__srv__get_ctrl_modes_srv(PyObject * pymodule)
  {
    int8_t err;
    PyObject * pyobject_type_support = NULL;
    pyobject_type_support = PyCapsule_New(
      (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, deepracer_interfaces_pkg, srv, GetCtrlModesSrv)(),
      NULL, NULL);
    if (!pyobject_type_support) {
      // previously added objects will be removed when the module is destroyed
      return -1;
    }
    err = PyModule_AddObject(
      pymodule,
      "type_support_srv__srv__get_ctrl_modes_srv",
      pyobject_type_support);
    if (err) {
      // the created capsule needs to be decremented
      Py_XDECREF(pyobject_type_support);
      // previously added objects will be removed when the module is destroyed
      return err;
    }
    return 0;
  }
  
  PyMODINIT_FUNC
  PyInit_deepracer_interfaces_pkg_s__rosidl_typesupport_introspection_c(void)
  {
    PyObject * pymodule = NULL;
    pymodule = PyModule_Create(&deepracer_interfaces_pkg__module);
    if (!pymodule) {
      return NULL;
    }
    int8_t err;
  
    err = _register_msg_type__msg__camera_msg(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__msg__infer_results(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__msg__infer_results_array(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__msg__evo_sensor_msg(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__msg__servo_ctrl_msg(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__msg__network_connection_status(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__msg__software_update_pct_msg(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__msg__usb_file_system_notification_msg(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__msg__detection_delta_msg(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__active_state_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__active_state_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__active_state_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__battery_level_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__battery_level_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__battery_level_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__begin_software_update_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__begin_software_update_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__begin_software_update_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__console_model_action_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__console_model_action_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__console_model_action_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__enable_state_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__enable_state_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__enable_state_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__get_calibration_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__get_calibration_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__get_calibration_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__get_device_info_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__get_device_info_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__get_device_info_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__get_led_ctrl_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__get_led_ctrl_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__get_led_ctrl_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__get_model_loading_status_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__get_model_loading_status_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__get_model_loading_status_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__inference_state_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__inference_state_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__inference_state_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__lidar_config_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__lidar_config_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__lidar_config_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__load_model_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__load_model_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__load_model_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__model_optimize_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__model_optimize_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__model_optimize_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__model_state_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__model_state_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__model_state_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__nav_throttle_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__nav_throttle_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__nav_throttle_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__otg_link_state_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__otg_link_state_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__otg_link_state_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__sensor_status_check_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__sensor_status_check_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__sensor_status_check_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__set_calibration_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__set_calibration_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__set_calibration_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__servo_gpio_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__servo_gpio_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__servo_gpio_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__set_led_ctrl_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__set_led_ctrl_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__set_led_ctrl_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__set_max_speed_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__set_max_speed_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__set_max_speed_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__set_status_led_blink_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__set_status_led_blink_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__set_status_led_blink_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__set_status_led_solid_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__set_status_led_solid_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__set_status_led_solid_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__software_update_check_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__software_update_check_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__software_update_check_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__software_update_state_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__software_update_state_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__software_update_state_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__usb_file_system_subscribe_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__usb_file_system_subscribe_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__usb_file_system_subscribe_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__usb_mount_point_manager_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__usb_mount_point_manager_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__usb_mount_point_manager_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__verify_model_ready_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__verify_model_ready_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__verify_model_ready_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__video_state_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__video_state_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__video_state_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__get_ctrl_modes_srv__request(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_msg_type__srv__get_ctrl_modes_srv__response(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    err = _register_srv_type__srv__get_ctrl_modes_srv(pymodule);
    if (err) {
      Py_XDECREF(pymodule);
      return NULL;
    }
  
    return pymodule;
  }
  