r2r/r2r_msg_gen/bindings/msg_bindings.rs

/* automatically generated by rust-bindgen 0.63.0 */

pub type rosidl_message_typesupport_handle_function = ::std::option::Option<
    unsafe extern "C" fn(
        arg1: *const rosidl_message_type_support_t,
        arg2: *const ::std::os::raw::c_char,
    ) -> *const rosidl_message_type_support_t,
>;
pub type __uint16_t = ::std::os::raw::c_ushort;
pub type __uint_least16_t = __uint16_t;
pub type uint_least16_t = __uint_least16_t;
#[repr(C)]
#[derive(Debug)]
pub struct unique_identifier_msgs__msg__UUID {
    pub uuid: [u8; 16usize],
}
#[test]
fn bindgen_test_layout_unique_identifier_msgs__msg__UUID() {
    const UNINIT: ::std::mem::MaybeUninit<unique_identifier_msgs__msg__UUID> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<unique_identifier_msgs__msg__UUID>(),
        16usize,
        concat!("Size of: ", stringify!(unique_identifier_msgs__msg__UUID))
    );
    assert_eq!(
        ::std::mem::align_of::<unique_identifier_msgs__msg__UUID>(),
        1usize,
        concat!(
            "Alignment of ",
            stringify!(unique_identifier_msgs__msg__UUID)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uuid) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(unique_identifier_msgs__msg__UUID),
            "::",
            stringify!(uuid)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct unique_identifier_msgs__msg__UUID__Sequence {
    pub data: *mut unique_identifier_msgs__msg__UUID,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_unique_identifier_msgs__msg__UUID__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<unique_identifier_msgs__msg__UUID__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<unique_identifier_msgs__msg__UUID__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(unique_identifier_msgs__msg__UUID__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<unique_identifier_msgs__msg__UUID__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(unique_identifier_msgs__msg__UUID__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(unique_identifier_msgs__msg__UUID__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(unique_identifier_msgs__msg__UUID__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(unique_identifier_msgs__msg__UUID__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct builtin_interfaces__msg__Time {
    pub sec: i32,
    pub nanosec: u32,
}
#[test]
fn bindgen_test_layout_builtin_interfaces__msg__Time() {
    const UNINIT: ::std::mem::MaybeUninit<builtin_interfaces__msg__Time> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<builtin_interfaces__msg__Time>(),
        8usize,
        concat!("Size of: ", stringify!(builtin_interfaces__msg__Time))
    );
    assert_eq!(
        ::std::mem::align_of::<builtin_interfaces__msg__Time>(),
        4usize,
        concat!("Alignment of ", stringify!(builtin_interfaces__msg__Time))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sec) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(builtin_interfaces__msg__Time),
            "::",
            stringify!(sec)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nanosec) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(builtin_interfaces__msg__Time),
            "::",
            stringify!(nanosec)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct builtin_interfaces__msg__Time__Sequence {
    pub data: *mut builtin_interfaces__msg__Time,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_builtin_interfaces__msg__Time__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<builtin_interfaces__msg__Time__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<builtin_interfaces__msg__Time__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(builtin_interfaces__msg__Time__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<builtin_interfaces__msg__Time__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(builtin_interfaces__msg__Time__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(builtin_interfaces__msg__Time__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(builtin_interfaces__msg__Time__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(builtin_interfaces__msg__Time__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct action_msgs__msg__GoalInfo {
    pub goal_id: unique_identifier_msgs__msg__UUID,
    pub stamp: builtin_interfaces__msg__Time,
}
#[test]
fn bindgen_test_layout_action_msgs__msg__GoalInfo() {
    const UNINIT: ::std::mem::MaybeUninit<action_msgs__msg__GoalInfo> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<action_msgs__msg__GoalInfo>(),
        24usize,
        concat!("Size of: ", stringify!(action_msgs__msg__GoalInfo))
    );
    assert_eq!(
        ::std::mem::align_of::<action_msgs__msg__GoalInfo>(),
        4usize,
        concat!("Alignment of ", stringify!(action_msgs__msg__GoalInfo))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).goal_id) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(action_msgs__msg__GoalInfo),
            "::",
            stringify!(goal_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).stamp) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(action_msgs__msg__GoalInfo),
            "::",
            stringify!(stamp)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct action_msgs__msg__GoalInfo__Sequence {
    pub data: *mut action_msgs__msg__GoalInfo,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_action_msgs__msg__GoalInfo__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<action_msgs__msg__GoalInfo__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<action_msgs__msg__GoalInfo__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(action_msgs__msg__GoalInfo__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<action_msgs__msg__GoalInfo__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(action_msgs__msg__GoalInfo__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(action_msgs__msg__GoalInfo__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(action_msgs__msg__GoalInfo__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(action_msgs__msg__GoalInfo__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const action_msgs__msg__GoalStatus__STATUS_UNKNOWN: _bindgen_ty_1 =
    _bindgen_ty_1::action_msgs__msg__GoalStatus__STATUS_UNKNOWN;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_1 {
    action_msgs__msg__GoalStatus__STATUS_UNKNOWN = 0,
}
pub const action_msgs__msg__GoalStatus__STATUS_ACCEPTED: _bindgen_ty_2 =
    _bindgen_ty_2::action_msgs__msg__GoalStatus__STATUS_ACCEPTED;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_2 {
    action_msgs__msg__GoalStatus__STATUS_ACCEPTED = 1,
}
pub const action_msgs__msg__GoalStatus__STATUS_EXECUTING: _bindgen_ty_3 =
    _bindgen_ty_3::action_msgs__msg__GoalStatus__STATUS_EXECUTING;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_3 {
    action_msgs__msg__GoalStatus__STATUS_EXECUTING = 2,
}
pub const action_msgs__msg__GoalStatus__STATUS_CANCELING: _bindgen_ty_4 =
    _bindgen_ty_4::action_msgs__msg__GoalStatus__STATUS_CANCELING;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_4 {
    action_msgs__msg__GoalStatus__STATUS_CANCELING = 3,
}
pub const action_msgs__msg__GoalStatus__STATUS_SUCCEEDED: _bindgen_ty_5 =
    _bindgen_ty_5::action_msgs__msg__GoalStatus__STATUS_SUCCEEDED;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_5 {
    action_msgs__msg__GoalStatus__STATUS_SUCCEEDED = 4,
}
pub const action_msgs__msg__GoalStatus__STATUS_CANCELED: _bindgen_ty_6 =
    _bindgen_ty_6::action_msgs__msg__GoalStatus__STATUS_CANCELED;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_6 {
    action_msgs__msg__GoalStatus__STATUS_CANCELED = 5,
}
pub const action_msgs__msg__GoalStatus__STATUS_ABORTED: _bindgen_ty_7 =
    _bindgen_ty_7::action_msgs__msg__GoalStatus__STATUS_ABORTED;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_7 {
    action_msgs__msg__GoalStatus__STATUS_ABORTED = 6,
}
#[repr(C)]
#[derive(Debug)]
pub struct action_msgs__msg__GoalStatus {
    pub goal_info: action_msgs__msg__GoalInfo,
    pub status: i8,
}
#[test]
fn bindgen_test_layout_action_msgs__msg__GoalStatus() {
    const UNINIT: ::std::mem::MaybeUninit<action_msgs__msg__GoalStatus> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<action_msgs__msg__GoalStatus>(),
        28usize,
        concat!("Size of: ", stringify!(action_msgs__msg__GoalStatus))
    );
    assert_eq!(
        ::std::mem::align_of::<action_msgs__msg__GoalStatus>(),
        4usize,
        concat!("Alignment of ", stringify!(action_msgs__msg__GoalStatus))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).goal_info) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(action_msgs__msg__GoalStatus),
            "::",
            stringify!(goal_info)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).status) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(action_msgs__msg__GoalStatus),
            "::",
            stringify!(status)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct action_msgs__msg__GoalStatus__Sequence {
    pub data: *mut action_msgs__msg__GoalStatus,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_action_msgs__msg__GoalStatus__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<action_msgs__msg__GoalStatus__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<action_msgs__msg__GoalStatus__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(action_msgs__msg__GoalStatus__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<action_msgs__msg__GoalStatus__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(action_msgs__msg__GoalStatus__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(action_msgs__msg__GoalStatus__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(action_msgs__msg__GoalStatus__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(action_msgs__msg__GoalStatus__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct action_msgs__msg__GoalStatusArray {
    pub status_list: action_msgs__msg__GoalStatus__Sequence,
}
#[test]
fn bindgen_test_layout_action_msgs__msg__GoalStatusArray() {
    const UNINIT: ::std::mem::MaybeUninit<action_msgs__msg__GoalStatusArray> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<action_msgs__msg__GoalStatusArray>(),
        24usize,
        concat!("Size of: ", stringify!(action_msgs__msg__GoalStatusArray))
    );
    assert_eq!(
        ::std::mem::align_of::<action_msgs__msg__GoalStatusArray>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(action_msgs__msg__GoalStatusArray)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).status_list) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(action_msgs__msg__GoalStatusArray),
            "::",
            stringify!(status_list)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct action_msgs__msg__GoalStatusArray__Sequence {
    pub data: *mut action_msgs__msg__GoalStatusArray,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_action_msgs__msg__GoalStatusArray__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<action_msgs__msg__GoalStatusArray__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<action_msgs__msg__GoalStatusArray__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(action_msgs__msg__GoalStatusArray__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<action_msgs__msg__GoalStatusArray__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(action_msgs__msg__GoalStatusArray__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(action_msgs__msg__GoalStatusArray__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(action_msgs__msg__GoalStatusArray__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(action_msgs__msg__GoalStatusArray__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct action_msgs__srv__CancelGoal_Request {
    pub goal_info: action_msgs__msg__GoalInfo,
}
#[test]
fn bindgen_test_layout_action_msgs__srv__CancelGoal_Request() {
    const UNINIT: ::std::mem::MaybeUninit<action_msgs__srv__CancelGoal_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<action_msgs__srv__CancelGoal_Request>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(action_msgs__srv__CancelGoal_Request)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<action_msgs__srv__CancelGoal_Request>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(action_msgs__srv__CancelGoal_Request)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).goal_info) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(action_msgs__srv__CancelGoal_Request),
            "::",
            stringify!(goal_info)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct action_msgs__srv__CancelGoal_Request__Sequence {
    pub data: *mut action_msgs__srv__CancelGoal_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_action_msgs__srv__CancelGoal_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<action_msgs__srv__CancelGoal_Request__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<action_msgs__srv__CancelGoal_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(action_msgs__srv__CancelGoal_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<action_msgs__srv__CancelGoal_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(action_msgs__srv__CancelGoal_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(action_msgs__srv__CancelGoal_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(action_msgs__srv__CancelGoal_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(action_msgs__srv__CancelGoal_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const action_msgs__srv__CancelGoal_Response__ERROR_NONE: _bindgen_ty_8 =
    _bindgen_ty_8::action_msgs__srv__CancelGoal_Response__ERROR_NONE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_8 {
    action_msgs__srv__CancelGoal_Response__ERROR_NONE = 0,
}
pub const action_msgs__srv__CancelGoal_Response__ERROR_REJECTED: _bindgen_ty_9 =
    _bindgen_ty_9::action_msgs__srv__CancelGoal_Response__ERROR_REJECTED;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_9 {
    action_msgs__srv__CancelGoal_Response__ERROR_REJECTED = 1,
}
pub const action_msgs__srv__CancelGoal_Response__ERROR_UNKNOWN_GOAL_ID: _bindgen_ty_10 =
    _bindgen_ty_10::action_msgs__srv__CancelGoal_Response__ERROR_UNKNOWN_GOAL_ID;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_10 {
    action_msgs__srv__CancelGoal_Response__ERROR_UNKNOWN_GOAL_ID = 2,
}
pub const action_msgs__srv__CancelGoal_Response__ERROR_GOAL_TERMINATED: _bindgen_ty_11 =
    _bindgen_ty_11::action_msgs__srv__CancelGoal_Response__ERROR_GOAL_TERMINATED;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_11 {
    action_msgs__srv__CancelGoal_Response__ERROR_GOAL_TERMINATED = 3,
}
#[repr(C)]
#[derive(Debug)]
pub struct action_msgs__srv__CancelGoal_Response {
    pub return_code: i8,
    pub goals_canceling: action_msgs__msg__GoalInfo__Sequence,
}
#[test]
fn bindgen_test_layout_action_msgs__srv__CancelGoal_Response() {
    const UNINIT: ::std::mem::MaybeUninit<action_msgs__srv__CancelGoal_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<action_msgs__srv__CancelGoal_Response>(),
        32usize,
        concat!(
            "Size of: ",
            stringify!(action_msgs__srv__CancelGoal_Response)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<action_msgs__srv__CancelGoal_Response>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(action_msgs__srv__CancelGoal_Response)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).return_code) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(action_msgs__srv__CancelGoal_Response),
            "::",
            stringify!(return_code)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).goals_canceling) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(action_msgs__srv__CancelGoal_Response),
            "::",
            stringify!(goals_canceling)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct action_msgs__srv__CancelGoal_Response__Sequence {
    pub data: *mut action_msgs__srv__CancelGoal_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_action_msgs__srv__CancelGoal_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<action_msgs__srv__CancelGoal_Response__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<action_msgs__srv__CancelGoal_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(action_msgs__srv__CancelGoal_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<action_msgs__srv__CancelGoal_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(action_msgs__srv__CancelGoal_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(action_msgs__srv__CancelGoal_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(action_msgs__srv__CancelGoal_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(action_msgs__srv__CancelGoal_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub type rosidl_service_typesupport_handle_function = ::std::option::Option<
    unsafe extern "C" fn(
        arg1: *const rosidl_service_type_support_t,
        arg2: *const ::std::os::raw::c_char,
    ) -> *const rosidl_service_type_support_t,
>;
#[repr(C)]
#[derive(Debug)]
pub struct builtin_interfaces__msg__Duration {
    pub sec: i32,
    pub nanosec: u32,
}
#[test]
fn bindgen_test_layout_builtin_interfaces__msg__Duration() {
    const UNINIT: ::std::mem::MaybeUninit<builtin_interfaces__msg__Duration> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<builtin_interfaces__msg__Duration>(),
        8usize,
        concat!("Size of: ", stringify!(builtin_interfaces__msg__Duration))
    );
    assert_eq!(
        ::std::mem::align_of::<builtin_interfaces__msg__Duration>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(builtin_interfaces__msg__Duration)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sec) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(builtin_interfaces__msg__Duration),
            "::",
            stringify!(sec)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nanosec) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(builtin_interfaces__msg__Duration),
            "::",
            stringify!(nanosec)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct builtin_interfaces__msg__Duration__Sequence {
    pub data: *mut builtin_interfaces__msg__Duration,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_builtin_interfaces__msg__Duration__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<builtin_interfaces__msg__Duration__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<builtin_interfaces__msg__Duration__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(builtin_interfaces__msg__Duration__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<builtin_interfaces__msg__Duration__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(builtin_interfaces__msg__Duration__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(builtin_interfaces__msg__Duration__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(builtin_interfaces__msg__Duration__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(builtin_interfaces__msg__Duration__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct std_msgs__msg__Header {
    pub stamp: builtin_interfaces__msg__Time,
    pub frame_id: rosidl_runtime_c__String,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Header() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Header> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Header>(),
        32usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Header))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Header>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__Header))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).stamp) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Header),
            "::",
            stringify!(stamp)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).frame_id) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Header),
            "::",
            stringify!(frame_id)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Header__Sequence {
    pub data: *mut std_msgs__msg__Header,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Header__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Header__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Header__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Header__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Header__Sequence>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__Header__Sequence))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Header__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Header__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Header__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const diagnostic_msgs__msg__DiagnosticStatus__OK: _bindgen_ty_12 =
    _bindgen_ty_12::diagnostic_msgs__msg__DiagnosticStatus__OK;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_12 {
    diagnostic_msgs__msg__DiagnosticStatus__OK = 0,
}
pub const diagnostic_msgs__msg__DiagnosticStatus__WARN: _bindgen_ty_13 =
    _bindgen_ty_13::diagnostic_msgs__msg__DiagnosticStatus__WARN;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_13 {
    diagnostic_msgs__msg__DiagnosticStatus__WARN = 1,
}
pub const diagnostic_msgs__msg__DiagnosticStatus__ERROR: _bindgen_ty_14 =
    _bindgen_ty_14::diagnostic_msgs__msg__DiagnosticStatus__ERROR;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_14 {
    diagnostic_msgs__msg__DiagnosticStatus__ERROR = 2,
}
pub const diagnostic_msgs__msg__DiagnosticStatus__STALE: _bindgen_ty_15 =
    _bindgen_ty_15::diagnostic_msgs__msg__DiagnosticStatus__STALE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_15 {
    diagnostic_msgs__msg__DiagnosticStatus__STALE = 3,
}
#[repr(C)]
pub struct diagnostic_msgs__msg__KeyValue {
    pub key: rosidl_runtime_c__String,
    pub value: rosidl_runtime_c__String,
}
#[test]
fn bindgen_test_layout_diagnostic_msgs__msg__KeyValue() {
    const UNINIT: ::std::mem::MaybeUninit<diagnostic_msgs__msg__KeyValue> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<diagnostic_msgs__msg__KeyValue>(),
        48usize,
        concat!("Size of: ", stringify!(diagnostic_msgs__msg__KeyValue))
    );
    assert_eq!(
        ::std::mem::align_of::<diagnostic_msgs__msg__KeyValue>(),
        8usize,
        concat!("Alignment of ", stringify!(diagnostic_msgs__msg__KeyValue))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).key) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__msg__KeyValue),
            "::",
            stringify!(key)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__msg__KeyValue),
            "::",
            stringify!(value)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct diagnostic_msgs__msg__KeyValue__Sequence {
    pub data: *mut diagnostic_msgs__msg__KeyValue,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_diagnostic_msgs__msg__KeyValue__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<diagnostic_msgs__msg__KeyValue__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<diagnostic_msgs__msg__KeyValue__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(diagnostic_msgs__msg__KeyValue__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<diagnostic_msgs__msg__KeyValue__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(diagnostic_msgs__msg__KeyValue__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__msg__KeyValue__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__msg__KeyValue__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__msg__KeyValue__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct diagnostic_msgs__msg__DiagnosticStatus {
    pub level: u8,
    pub name: rosidl_runtime_c__String,
    pub message: rosidl_runtime_c__String,
    pub hardware_id: rosidl_runtime_c__String,
    pub values: diagnostic_msgs__msg__KeyValue__Sequence,
}
#[test]
fn bindgen_test_layout_diagnostic_msgs__msg__DiagnosticStatus() {
    const UNINIT: ::std::mem::MaybeUninit<diagnostic_msgs__msg__DiagnosticStatus> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<diagnostic_msgs__msg__DiagnosticStatus>(),
        104usize,
        concat!(
            "Size of: ",
            stringify!(diagnostic_msgs__msg__DiagnosticStatus)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<diagnostic_msgs__msg__DiagnosticStatus>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(diagnostic_msgs__msg__DiagnosticStatus)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).level) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__msg__DiagnosticStatus),
            "::",
            stringify!(level)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__msg__DiagnosticStatus),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).message) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__msg__DiagnosticStatus),
            "::",
            stringify!(message)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hardware_id) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__msg__DiagnosticStatus),
            "::",
            stringify!(hardware_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).values) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__msg__DiagnosticStatus),
            "::",
            stringify!(values)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct diagnostic_msgs__msg__DiagnosticStatus__Sequence {
    pub data: *mut diagnostic_msgs__msg__DiagnosticStatus,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_diagnostic_msgs__msg__DiagnosticStatus__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<diagnostic_msgs__msg__DiagnosticStatus__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<diagnostic_msgs__msg__DiagnosticStatus__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(diagnostic_msgs__msg__DiagnosticStatus__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<diagnostic_msgs__msg__DiagnosticStatus__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(diagnostic_msgs__msg__DiagnosticStatus__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__msg__DiagnosticStatus__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__msg__DiagnosticStatus__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__msg__DiagnosticStatus__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct diagnostic_msgs__msg__DiagnosticArray {
    pub header: std_msgs__msg__Header,
    pub status: diagnostic_msgs__msg__DiagnosticStatus__Sequence,
}
#[test]
fn bindgen_test_layout_diagnostic_msgs__msg__DiagnosticArray() {
    const UNINIT: ::std::mem::MaybeUninit<diagnostic_msgs__msg__DiagnosticArray> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<diagnostic_msgs__msg__DiagnosticArray>(),
        56usize,
        concat!(
            "Size of: ",
            stringify!(diagnostic_msgs__msg__DiagnosticArray)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<diagnostic_msgs__msg__DiagnosticArray>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(diagnostic_msgs__msg__DiagnosticArray)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__msg__DiagnosticArray),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).status) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__msg__DiagnosticArray),
            "::",
            stringify!(status)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct diagnostic_msgs__msg__DiagnosticArray__Sequence {
    pub data: *mut diagnostic_msgs__msg__DiagnosticArray,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_diagnostic_msgs__msg__DiagnosticArray__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<diagnostic_msgs__msg__DiagnosticArray__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<diagnostic_msgs__msg__DiagnosticArray__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(diagnostic_msgs__msg__DiagnosticArray__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<diagnostic_msgs__msg__DiagnosticArray__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(diagnostic_msgs__msg__DiagnosticArray__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__msg__DiagnosticArray__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__msg__DiagnosticArray__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__msg__DiagnosticArray__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct diagnostic_msgs__srv__AddDiagnostics_Request {
    pub load_namespace: rosidl_runtime_c__String,
}
#[test]
fn bindgen_test_layout_diagnostic_msgs__srv__AddDiagnostics_Request() {
    const UNINIT: ::std::mem::MaybeUninit<diagnostic_msgs__srv__AddDiagnostics_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<diagnostic_msgs__srv__AddDiagnostics_Request>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(diagnostic_msgs__srv__AddDiagnostics_Request)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<diagnostic_msgs__srv__AddDiagnostics_Request>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(diagnostic_msgs__srv__AddDiagnostics_Request)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).load_namespace) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__srv__AddDiagnostics_Request),
            "::",
            stringify!(load_namespace)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct diagnostic_msgs__srv__AddDiagnostics_Request__Sequence {
    pub data: *mut diagnostic_msgs__srv__AddDiagnostics_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_diagnostic_msgs__srv__AddDiagnostics_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<diagnostic_msgs__srv__AddDiagnostics_Request__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<diagnostic_msgs__srv__AddDiagnostics_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(diagnostic_msgs__srv__AddDiagnostics_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<diagnostic_msgs__srv__AddDiagnostics_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(diagnostic_msgs__srv__AddDiagnostics_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__srv__AddDiagnostics_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__srv__AddDiagnostics_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__srv__AddDiagnostics_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct diagnostic_msgs__srv__AddDiagnostics_Response {
    pub success: bool,
    pub message: rosidl_runtime_c__String,
}
#[test]
fn bindgen_test_layout_diagnostic_msgs__srv__AddDiagnostics_Response() {
    const UNINIT: ::std::mem::MaybeUninit<diagnostic_msgs__srv__AddDiagnostics_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<diagnostic_msgs__srv__AddDiagnostics_Response>(),
        32usize,
        concat!(
            "Size of: ",
            stringify!(diagnostic_msgs__srv__AddDiagnostics_Response)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<diagnostic_msgs__srv__AddDiagnostics_Response>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(diagnostic_msgs__srv__AddDiagnostics_Response)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).success) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__srv__AddDiagnostics_Response),
            "::",
            stringify!(success)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).message) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__srv__AddDiagnostics_Response),
            "::",
            stringify!(message)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct diagnostic_msgs__srv__AddDiagnostics_Response__Sequence {
    pub data: *mut diagnostic_msgs__srv__AddDiagnostics_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_diagnostic_msgs__srv__AddDiagnostics_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<diagnostic_msgs__srv__AddDiagnostics_Response__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<diagnostic_msgs__srv__AddDiagnostics_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(diagnostic_msgs__srv__AddDiagnostics_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<diagnostic_msgs__srv__AddDiagnostics_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(diagnostic_msgs__srv__AddDiagnostics_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__srv__AddDiagnostics_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__srv__AddDiagnostics_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__srv__AddDiagnostics_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct diagnostic_msgs__srv__SelfTest_Request {
    pub structure_needs_at_least_one_member: u8,
}
#[test]
fn bindgen_test_layout_diagnostic_msgs__srv__SelfTest_Request() {
    const UNINIT: ::std::mem::MaybeUninit<diagnostic_msgs__srv__SelfTest_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<diagnostic_msgs__srv__SelfTest_Request>(),
        1usize,
        concat!(
            "Size of: ",
            stringify!(diagnostic_msgs__srv__SelfTest_Request)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<diagnostic_msgs__srv__SelfTest_Request>(),
        1usize,
        concat!(
            "Alignment of ",
            stringify!(diagnostic_msgs__srv__SelfTest_Request)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).structure_needs_at_least_one_member) as usize - ptr as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__srv__SelfTest_Request),
            "::",
            stringify!(structure_needs_at_least_one_member)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct diagnostic_msgs__srv__SelfTest_Request__Sequence {
    pub data: *mut diagnostic_msgs__srv__SelfTest_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_diagnostic_msgs__srv__SelfTest_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<diagnostic_msgs__srv__SelfTest_Request__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<diagnostic_msgs__srv__SelfTest_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(diagnostic_msgs__srv__SelfTest_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<diagnostic_msgs__srv__SelfTest_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(diagnostic_msgs__srv__SelfTest_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__srv__SelfTest_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__srv__SelfTest_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__srv__SelfTest_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct diagnostic_msgs__srv__SelfTest_Response {
    pub id: rosidl_runtime_c__String,
    pub passed: u8,
    pub status: diagnostic_msgs__msg__DiagnosticStatus__Sequence,
}
#[test]
fn bindgen_test_layout_diagnostic_msgs__srv__SelfTest_Response() {
    const UNINIT: ::std::mem::MaybeUninit<diagnostic_msgs__srv__SelfTest_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<diagnostic_msgs__srv__SelfTest_Response>(),
        56usize,
        concat!(
            "Size of: ",
            stringify!(diagnostic_msgs__srv__SelfTest_Response)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<diagnostic_msgs__srv__SelfTest_Response>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(diagnostic_msgs__srv__SelfTest_Response)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__srv__SelfTest_Response),
            "::",
            stringify!(id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).passed) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__srv__SelfTest_Response),
            "::",
            stringify!(passed)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).status) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__srv__SelfTest_Response),
            "::",
            stringify!(status)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct diagnostic_msgs__srv__SelfTest_Response__Sequence {
    pub data: *mut diagnostic_msgs__srv__SelfTest_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_diagnostic_msgs__srv__SelfTest_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<diagnostic_msgs__srv__SelfTest_Response__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<diagnostic_msgs__srv__SelfTest_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(diagnostic_msgs__srv__SelfTest_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<diagnostic_msgs__srv__SelfTest_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(diagnostic_msgs__srv__SelfTest_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__srv__SelfTest_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__srv__SelfTest_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(diagnostic_msgs__srv__SelfTest_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__Vector3 {
    pub x: f64,
    pub y: f64,
    pub z: f64,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Vector3() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Vector3> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Vector3>(),
        24usize,
        concat!("Size of: ", stringify!(geometry_msgs__msg__Vector3))
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Vector3>(),
        8usize,
        concat!("Alignment of ", stringify!(geometry_msgs__msg__Vector3))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Vector3),
            "::",
            stringify!(x)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Vector3),
            "::",
            stringify!(y)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Vector3),
            "::",
            stringify!(z)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__Vector3__Sequence {
    pub data: *mut geometry_msgs__msg__Vector3,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Vector3__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Vector3__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Vector3__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__Vector3__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Vector3__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__Vector3__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Vector3__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Vector3__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Vector3__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__Accel {
    pub linear: geometry_msgs__msg__Vector3,
    pub angular: geometry_msgs__msg__Vector3,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Accel() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Accel> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Accel>(),
        48usize,
        concat!("Size of: ", stringify!(geometry_msgs__msg__Accel))
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Accel>(),
        8usize,
        concat!("Alignment of ", stringify!(geometry_msgs__msg__Accel))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).linear) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Accel),
            "::",
            stringify!(linear)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).angular) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Accel),
            "::",
            stringify!(angular)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__Accel__Sequence {
    pub data: *mut geometry_msgs__msg__Accel,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Accel__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Accel__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Accel__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(geometry_msgs__msg__Accel__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Accel__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__Accel__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Accel__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Accel__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Accel__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct geometry_msgs__msg__AccelStamped {
    pub header: std_msgs__msg__Header,
    pub accel: geometry_msgs__msg__Accel,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__AccelStamped() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__AccelStamped> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__AccelStamped>(),
        80usize,
        concat!("Size of: ", stringify!(geometry_msgs__msg__AccelStamped))
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__AccelStamped>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__AccelStamped)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__AccelStamped),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).accel) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__AccelStamped),
            "::",
            stringify!(accel)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__AccelStamped__Sequence {
    pub data: *mut geometry_msgs__msg__AccelStamped,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__AccelStamped__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__AccelStamped__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__AccelStamped__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__AccelStamped__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__AccelStamped__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__AccelStamped__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__AccelStamped__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__AccelStamped__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__AccelStamped__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__AccelWithCovariance {
    pub accel: geometry_msgs__msg__Accel,
    pub covariance: [f64; 36usize],
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__AccelWithCovariance() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__AccelWithCovariance> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__AccelWithCovariance>(),
        336usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__AccelWithCovariance)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__AccelWithCovariance>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__AccelWithCovariance)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).accel) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__AccelWithCovariance),
            "::",
            stringify!(accel)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).covariance) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__AccelWithCovariance),
            "::",
            stringify!(covariance)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__AccelWithCovariance__Sequence {
    pub data: *mut geometry_msgs__msg__AccelWithCovariance,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__AccelWithCovariance__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__AccelWithCovariance__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__AccelWithCovariance__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__AccelWithCovariance__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__AccelWithCovariance__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__AccelWithCovariance__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__AccelWithCovariance__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__AccelWithCovariance__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__AccelWithCovariance__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct geometry_msgs__msg__AccelWithCovarianceStamped {
    pub header: std_msgs__msg__Header,
    pub accel: geometry_msgs__msg__AccelWithCovariance,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__AccelWithCovarianceStamped() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__AccelWithCovarianceStamped> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__AccelWithCovarianceStamped>(),
        368usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__AccelWithCovarianceStamped)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__AccelWithCovarianceStamped>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__AccelWithCovarianceStamped)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__AccelWithCovarianceStamped),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).accel) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__AccelWithCovarianceStamped),
            "::",
            stringify!(accel)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__AccelWithCovarianceStamped__Sequence {
    pub data: *mut geometry_msgs__msg__AccelWithCovarianceStamped,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__AccelWithCovarianceStamped__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        geometry_msgs__msg__AccelWithCovarianceStamped__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__AccelWithCovarianceStamped__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__AccelWithCovarianceStamped__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__AccelWithCovarianceStamped__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__AccelWithCovarianceStamped__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__AccelWithCovarianceStamped__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__AccelWithCovarianceStamped__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__AccelWithCovarianceStamped__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__Inertia {
    pub m: f64,
    pub com: geometry_msgs__msg__Vector3,
    pub ixx: f64,
    pub ixy: f64,
    pub ixz: f64,
    pub iyy: f64,
    pub iyz: f64,
    pub izz: f64,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Inertia() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Inertia> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Inertia>(),
        80usize,
        concat!("Size of: ", stringify!(geometry_msgs__msg__Inertia))
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Inertia>(),
        8usize,
        concat!("Alignment of ", stringify!(geometry_msgs__msg__Inertia))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).m) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Inertia),
            "::",
            stringify!(m)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).com) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Inertia),
            "::",
            stringify!(com)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ixx) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Inertia),
            "::",
            stringify!(ixx)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ixy) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Inertia),
            "::",
            stringify!(ixy)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ixz) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Inertia),
            "::",
            stringify!(ixz)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).iyy) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Inertia),
            "::",
            stringify!(iyy)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).iyz) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Inertia),
            "::",
            stringify!(iyz)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).izz) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Inertia),
            "::",
            stringify!(izz)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__Inertia__Sequence {
    pub data: *mut geometry_msgs__msg__Inertia,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Inertia__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Inertia__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Inertia__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__Inertia__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Inertia__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__Inertia__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Inertia__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Inertia__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Inertia__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct geometry_msgs__msg__InertiaStamped {
    pub header: std_msgs__msg__Header,
    pub inertia: geometry_msgs__msg__Inertia,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__InertiaStamped() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__InertiaStamped> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__InertiaStamped>(),
        112usize,
        concat!("Size of: ", stringify!(geometry_msgs__msg__InertiaStamped))
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__InertiaStamped>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__InertiaStamped)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__InertiaStamped),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).inertia) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__InertiaStamped),
            "::",
            stringify!(inertia)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__InertiaStamped__Sequence {
    pub data: *mut geometry_msgs__msg__InertiaStamped,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__InertiaStamped__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__InertiaStamped__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__InertiaStamped__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__InertiaStamped__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__InertiaStamped__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__InertiaStamped__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__InertiaStamped__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__InertiaStamped__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__InertiaStamped__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__Point {
    pub x: f64,
    pub y: f64,
    pub z: f64,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Point() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Point> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Point>(),
        24usize,
        concat!("Size of: ", stringify!(geometry_msgs__msg__Point))
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Point>(),
        8usize,
        concat!("Alignment of ", stringify!(geometry_msgs__msg__Point))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Point),
            "::",
            stringify!(x)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Point),
            "::",
            stringify!(y)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Point),
            "::",
            stringify!(z)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__Point__Sequence {
    pub data: *mut geometry_msgs__msg__Point,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Point__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Point__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Point__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(geometry_msgs__msg__Point__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Point__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__Point__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Point__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Point__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Point__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__Point32 {
    pub x: f32,
    pub y: f32,
    pub z: f32,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Point32() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Point32> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Point32>(),
        12usize,
        concat!("Size of: ", stringify!(geometry_msgs__msg__Point32))
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Point32>(),
        4usize,
        concat!("Alignment of ", stringify!(geometry_msgs__msg__Point32))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Point32),
            "::",
            stringify!(x)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Point32),
            "::",
            stringify!(y)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Point32),
            "::",
            stringify!(z)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__Point32__Sequence {
    pub data: *mut geometry_msgs__msg__Point32,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Point32__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Point32__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Point32__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__Point32__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Point32__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__Point32__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Point32__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Point32__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Point32__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct geometry_msgs__msg__PointStamped {
    pub header: std_msgs__msg__Header,
    pub point: geometry_msgs__msg__Point,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__PointStamped() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__PointStamped> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__PointStamped>(),
        56usize,
        concat!("Size of: ", stringify!(geometry_msgs__msg__PointStamped))
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__PointStamped>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__PointStamped)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PointStamped),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).point) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PointStamped),
            "::",
            stringify!(point)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__PointStamped__Sequence {
    pub data: *mut geometry_msgs__msg__PointStamped,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__PointStamped__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__PointStamped__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__PointStamped__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__PointStamped__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__PointStamped__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__PointStamped__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PointStamped__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PointStamped__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PointStamped__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__Polygon {
    pub points: geometry_msgs__msg__Point32__Sequence,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Polygon() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Polygon> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Polygon>(),
        24usize,
        concat!("Size of: ", stringify!(geometry_msgs__msg__Polygon))
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Polygon>(),
        8usize,
        concat!("Alignment of ", stringify!(geometry_msgs__msg__Polygon))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).points) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Polygon),
            "::",
            stringify!(points)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__Polygon__Sequence {
    pub data: *mut geometry_msgs__msg__Polygon,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Polygon__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Polygon__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Polygon__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__Polygon__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Polygon__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__Polygon__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Polygon__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Polygon__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Polygon__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct geometry_msgs__msg__PolygonStamped {
    pub header: std_msgs__msg__Header,
    pub polygon: geometry_msgs__msg__Polygon,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__PolygonStamped() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__PolygonStamped> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__PolygonStamped>(),
        56usize,
        concat!("Size of: ", stringify!(geometry_msgs__msg__PolygonStamped))
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__PolygonStamped>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__PolygonStamped)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PolygonStamped),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).polygon) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PolygonStamped),
            "::",
            stringify!(polygon)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__PolygonStamped__Sequence {
    pub data: *mut geometry_msgs__msg__PolygonStamped,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__PolygonStamped__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__PolygonStamped__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__PolygonStamped__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__PolygonStamped__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__PolygonStamped__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__PolygonStamped__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PolygonStamped__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PolygonStamped__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PolygonStamped__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__Quaternion {
    pub x: f64,
    pub y: f64,
    pub z: f64,
    pub w: f64,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Quaternion() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Quaternion> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Quaternion>(),
        32usize,
        concat!("Size of: ", stringify!(geometry_msgs__msg__Quaternion))
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Quaternion>(),
        8usize,
        concat!("Alignment of ", stringify!(geometry_msgs__msg__Quaternion))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Quaternion),
            "::",
            stringify!(x)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Quaternion),
            "::",
            stringify!(y)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Quaternion),
            "::",
            stringify!(z)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).w) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Quaternion),
            "::",
            stringify!(w)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__Quaternion__Sequence {
    pub data: *mut geometry_msgs__msg__Quaternion,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Quaternion__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Quaternion__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Quaternion__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__Quaternion__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Quaternion__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__Quaternion__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Quaternion__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Quaternion__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Quaternion__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__Pose {
    pub position: geometry_msgs__msg__Point,
    pub orientation: geometry_msgs__msg__Quaternion,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Pose() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Pose> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Pose>(),
        56usize,
        concat!("Size of: ", stringify!(geometry_msgs__msg__Pose))
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Pose>(),
        8usize,
        concat!("Alignment of ", stringify!(geometry_msgs__msg__Pose))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).position) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Pose),
            "::",
            stringify!(position)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).orientation) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Pose),
            "::",
            stringify!(orientation)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__Pose__Sequence {
    pub data: *mut geometry_msgs__msg__Pose,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Pose__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Pose__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Pose__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(geometry_msgs__msg__Pose__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Pose__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__Pose__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Pose__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Pose__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Pose__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__Pose2D {
    pub x: f64,
    pub y: f64,
    pub theta: f64,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Pose2D() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Pose2D> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Pose2D>(),
        24usize,
        concat!("Size of: ", stringify!(geometry_msgs__msg__Pose2D))
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Pose2D>(),
        8usize,
        concat!("Alignment of ", stringify!(geometry_msgs__msg__Pose2D))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Pose2D),
            "::",
            stringify!(x)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Pose2D),
            "::",
            stringify!(y)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).theta) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Pose2D),
            "::",
            stringify!(theta)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__Pose2D__Sequence {
    pub data: *mut geometry_msgs__msg__Pose2D,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Pose2D__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Pose2D__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Pose2D__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__Pose2D__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Pose2D__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__Pose2D__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Pose2D__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Pose2D__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Pose2D__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct geometry_msgs__msg__PoseArray {
    pub header: std_msgs__msg__Header,
    pub poses: geometry_msgs__msg__Pose__Sequence,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__PoseArray() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__PoseArray> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__PoseArray>(),
        56usize,
        concat!("Size of: ", stringify!(geometry_msgs__msg__PoseArray))
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__PoseArray>(),
        8usize,
        concat!("Alignment of ", stringify!(geometry_msgs__msg__PoseArray))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PoseArray),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).poses) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PoseArray),
            "::",
            stringify!(poses)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__PoseArray__Sequence {
    pub data: *mut geometry_msgs__msg__PoseArray,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__PoseArray__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__PoseArray__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__PoseArray__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__PoseArray__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__PoseArray__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__PoseArray__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PoseArray__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PoseArray__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PoseArray__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct geometry_msgs__msg__PoseStamped {
    pub header: std_msgs__msg__Header,
    pub pose: geometry_msgs__msg__Pose,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__PoseStamped() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__PoseStamped> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__PoseStamped>(),
        88usize,
        concat!("Size of: ", stringify!(geometry_msgs__msg__PoseStamped))
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__PoseStamped>(),
        8usize,
        concat!("Alignment of ", stringify!(geometry_msgs__msg__PoseStamped))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PoseStamped),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pose) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PoseStamped),
            "::",
            stringify!(pose)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__PoseStamped__Sequence {
    pub data: *mut geometry_msgs__msg__PoseStamped,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__PoseStamped__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__PoseStamped__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__PoseStamped__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__PoseStamped__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__PoseStamped__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__PoseStamped__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PoseStamped__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PoseStamped__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PoseStamped__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__PoseWithCovariance {
    pub pose: geometry_msgs__msg__Pose,
    pub covariance: [f64; 36usize],
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__PoseWithCovariance() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__PoseWithCovariance> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__PoseWithCovariance>(),
        344usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__PoseWithCovariance)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__PoseWithCovariance>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__PoseWithCovariance)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pose) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PoseWithCovariance),
            "::",
            stringify!(pose)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).covariance) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PoseWithCovariance),
            "::",
            stringify!(covariance)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__PoseWithCovariance__Sequence {
    pub data: *mut geometry_msgs__msg__PoseWithCovariance,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__PoseWithCovariance__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__PoseWithCovariance__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__PoseWithCovariance__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__PoseWithCovariance__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__PoseWithCovariance__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__PoseWithCovariance__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PoseWithCovariance__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PoseWithCovariance__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PoseWithCovariance__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct geometry_msgs__msg__PoseWithCovarianceStamped {
    pub header: std_msgs__msg__Header,
    pub pose: geometry_msgs__msg__PoseWithCovariance,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__PoseWithCovarianceStamped() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__PoseWithCovarianceStamped> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__PoseWithCovarianceStamped>(),
        376usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__PoseWithCovarianceStamped)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__PoseWithCovarianceStamped>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__PoseWithCovarianceStamped)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PoseWithCovarianceStamped),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pose) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PoseWithCovarianceStamped),
            "::",
            stringify!(pose)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__PoseWithCovarianceStamped__Sequence {
    pub data: *mut geometry_msgs__msg__PoseWithCovarianceStamped,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__PoseWithCovarianceStamped__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__PoseWithCovarianceStamped__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__PoseWithCovarianceStamped__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__PoseWithCovarianceStamped__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__PoseWithCovarianceStamped__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__PoseWithCovarianceStamped__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PoseWithCovarianceStamped__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PoseWithCovarianceStamped__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__PoseWithCovarianceStamped__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct geometry_msgs__msg__QuaternionStamped {
    pub header: std_msgs__msg__Header,
    pub quaternion: geometry_msgs__msg__Quaternion,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__QuaternionStamped() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__QuaternionStamped> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__QuaternionStamped>(),
        64usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__QuaternionStamped)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__QuaternionStamped>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__QuaternionStamped)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__QuaternionStamped),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).quaternion) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__QuaternionStamped),
            "::",
            stringify!(quaternion)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__QuaternionStamped__Sequence {
    pub data: *mut geometry_msgs__msg__QuaternionStamped,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__QuaternionStamped__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__QuaternionStamped__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__QuaternionStamped__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__QuaternionStamped__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__QuaternionStamped__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__QuaternionStamped__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__QuaternionStamped__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__QuaternionStamped__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__QuaternionStamped__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__Transform {
    pub translation: geometry_msgs__msg__Vector3,
    pub rotation: geometry_msgs__msg__Quaternion,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Transform() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Transform> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Transform>(),
        56usize,
        concat!("Size of: ", stringify!(geometry_msgs__msg__Transform))
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Transform>(),
        8usize,
        concat!("Alignment of ", stringify!(geometry_msgs__msg__Transform))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).translation) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Transform),
            "::",
            stringify!(translation)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).rotation) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Transform),
            "::",
            stringify!(rotation)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__Transform__Sequence {
    pub data: *mut geometry_msgs__msg__Transform,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Transform__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Transform__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Transform__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__Transform__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Transform__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__Transform__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Transform__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Transform__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Transform__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct geometry_msgs__msg__TransformStamped {
    pub header: std_msgs__msg__Header,
    pub child_frame_id: rosidl_runtime_c__String,
    pub transform: geometry_msgs__msg__Transform,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__TransformStamped() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__TransformStamped> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__TransformStamped>(),
        112usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__TransformStamped)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__TransformStamped>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__TransformStamped)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__TransformStamped),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).child_frame_id) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__TransformStamped),
            "::",
            stringify!(child_frame_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).transform) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__TransformStamped),
            "::",
            stringify!(transform)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__TransformStamped__Sequence {
    pub data: *mut geometry_msgs__msg__TransformStamped,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__TransformStamped__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__TransformStamped__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__TransformStamped__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__TransformStamped__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__TransformStamped__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__TransformStamped__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__TransformStamped__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__TransformStamped__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__TransformStamped__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__Twist {
    pub linear: geometry_msgs__msg__Vector3,
    pub angular: geometry_msgs__msg__Vector3,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Twist() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Twist> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Twist>(),
        48usize,
        concat!("Size of: ", stringify!(geometry_msgs__msg__Twist))
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Twist>(),
        8usize,
        concat!("Alignment of ", stringify!(geometry_msgs__msg__Twist))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).linear) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Twist),
            "::",
            stringify!(linear)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).angular) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Twist),
            "::",
            stringify!(angular)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__Twist__Sequence {
    pub data: *mut geometry_msgs__msg__Twist,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Twist__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Twist__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Twist__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(geometry_msgs__msg__Twist__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Twist__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__Twist__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Twist__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Twist__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Twist__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct geometry_msgs__msg__TwistStamped {
    pub header: std_msgs__msg__Header,
    pub twist: geometry_msgs__msg__Twist,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__TwistStamped() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__TwistStamped> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__TwistStamped>(),
        80usize,
        concat!("Size of: ", stringify!(geometry_msgs__msg__TwistStamped))
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__TwistStamped>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__TwistStamped)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__TwistStamped),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).twist) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__TwistStamped),
            "::",
            stringify!(twist)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__TwistStamped__Sequence {
    pub data: *mut geometry_msgs__msg__TwistStamped,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__TwistStamped__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__TwistStamped__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__TwistStamped__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__TwistStamped__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__TwistStamped__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__TwistStamped__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__TwistStamped__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__TwistStamped__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__TwistStamped__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__TwistWithCovariance {
    pub twist: geometry_msgs__msg__Twist,
    pub covariance: [f64; 36usize],
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__TwistWithCovariance() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__TwistWithCovariance> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__TwistWithCovariance>(),
        336usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__TwistWithCovariance)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__TwistWithCovariance>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__TwistWithCovariance)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).twist) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__TwistWithCovariance),
            "::",
            stringify!(twist)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).covariance) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__TwistWithCovariance),
            "::",
            stringify!(covariance)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__TwistWithCovariance__Sequence {
    pub data: *mut geometry_msgs__msg__TwistWithCovariance,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__TwistWithCovariance__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__TwistWithCovariance__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__TwistWithCovariance__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__TwistWithCovariance__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__TwistWithCovariance__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__TwistWithCovariance__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__TwistWithCovariance__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__TwistWithCovariance__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__TwistWithCovariance__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct geometry_msgs__msg__TwistWithCovarianceStamped {
    pub header: std_msgs__msg__Header,
    pub twist: geometry_msgs__msg__TwistWithCovariance,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__TwistWithCovarianceStamped() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__TwistWithCovarianceStamped> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__TwistWithCovarianceStamped>(),
        368usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__TwistWithCovarianceStamped)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__TwistWithCovarianceStamped>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__TwistWithCovarianceStamped)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__TwistWithCovarianceStamped),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).twist) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__TwistWithCovarianceStamped),
            "::",
            stringify!(twist)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__TwistWithCovarianceStamped__Sequence {
    pub data: *mut geometry_msgs__msg__TwistWithCovarianceStamped,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__TwistWithCovarianceStamped__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        geometry_msgs__msg__TwistWithCovarianceStamped__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__TwistWithCovarianceStamped__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__TwistWithCovarianceStamped__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__TwistWithCovarianceStamped__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__TwistWithCovarianceStamped__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__TwistWithCovarianceStamped__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__TwistWithCovarianceStamped__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__TwistWithCovarianceStamped__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct geometry_msgs__msg__Vector3Stamped {
    pub header: std_msgs__msg__Header,
    pub vector: geometry_msgs__msg__Vector3,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Vector3Stamped() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Vector3Stamped> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Vector3Stamped>(),
        56usize,
        concat!("Size of: ", stringify!(geometry_msgs__msg__Vector3Stamped))
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Vector3Stamped>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__Vector3Stamped)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Vector3Stamped),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).vector) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Vector3Stamped),
            "::",
            stringify!(vector)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__Vector3Stamped__Sequence {
    pub data: *mut geometry_msgs__msg__Vector3Stamped,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Vector3Stamped__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Vector3Stamped__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Vector3Stamped__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__Vector3Stamped__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Vector3Stamped__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__Vector3Stamped__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Vector3Stamped__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Vector3Stamped__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Vector3Stamped__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__Wrench {
    pub force: geometry_msgs__msg__Vector3,
    pub torque: geometry_msgs__msg__Vector3,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Wrench() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Wrench> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Wrench>(),
        48usize,
        concat!("Size of: ", stringify!(geometry_msgs__msg__Wrench))
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Wrench>(),
        8usize,
        concat!("Alignment of ", stringify!(geometry_msgs__msg__Wrench))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).force) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Wrench),
            "::",
            stringify!(force)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).torque) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Wrench),
            "::",
            stringify!(torque)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__Wrench__Sequence {
    pub data: *mut geometry_msgs__msg__Wrench,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__Wrench__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__Wrench__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__Wrench__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__Wrench__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__Wrench__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__Wrench__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Wrench__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Wrench__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__Wrench__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct geometry_msgs__msg__WrenchStamped {
    pub header: std_msgs__msg__Header,
    pub wrench: geometry_msgs__msg__Wrench,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__WrenchStamped() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__WrenchStamped> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__WrenchStamped>(),
        80usize,
        concat!("Size of: ", stringify!(geometry_msgs__msg__WrenchStamped))
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__WrenchStamped>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__WrenchStamped)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__WrenchStamped),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wrench) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__WrenchStamped),
            "::",
            stringify!(wrench)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct geometry_msgs__msg__WrenchStamped__Sequence {
    pub data: *mut geometry_msgs__msg__WrenchStamped,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_geometry_msgs__msg__WrenchStamped__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<geometry_msgs__msg__WrenchStamped__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<geometry_msgs__msg__WrenchStamped__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(geometry_msgs__msg__WrenchStamped__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<geometry_msgs__msg__WrenchStamped__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(geometry_msgs__msg__WrenchStamped__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__WrenchStamped__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__WrenchStamped__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(geometry_msgs__msg__WrenchStamped__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const lifecycle_msgs__msg__State__PRIMARY_STATE_UNKNOWN: _bindgen_ty_16 =
    _bindgen_ty_16::lifecycle_msgs__msg__State__PRIMARY_STATE_UNKNOWN;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_16 {
    lifecycle_msgs__msg__State__PRIMARY_STATE_UNKNOWN = 0,
}
pub const lifecycle_msgs__msg__State__PRIMARY_STATE_UNCONFIGURED: _bindgen_ty_17 =
    _bindgen_ty_17::lifecycle_msgs__msg__State__PRIMARY_STATE_UNCONFIGURED;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_17 {
    lifecycle_msgs__msg__State__PRIMARY_STATE_UNCONFIGURED = 1,
}
pub const lifecycle_msgs__msg__State__PRIMARY_STATE_INACTIVE: _bindgen_ty_18 =
    _bindgen_ty_18::lifecycle_msgs__msg__State__PRIMARY_STATE_INACTIVE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_18 {
    lifecycle_msgs__msg__State__PRIMARY_STATE_INACTIVE = 2,
}
pub const lifecycle_msgs__msg__State__PRIMARY_STATE_ACTIVE: _bindgen_ty_19 =
    _bindgen_ty_19::lifecycle_msgs__msg__State__PRIMARY_STATE_ACTIVE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_19 {
    lifecycle_msgs__msg__State__PRIMARY_STATE_ACTIVE = 3,
}
pub const lifecycle_msgs__msg__State__PRIMARY_STATE_FINALIZED: _bindgen_ty_20 =
    _bindgen_ty_20::lifecycle_msgs__msg__State__PRIMARY_STATE_FINALIZED;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_20 {
    lifecycle_msgs__msg__State__PRIMARY_STATE_FINALIZED = 4,
}
pub const lifecycle_msgs__msg__State__TRANSITION_STATE_CONFIGURING: _bindgen_ty_21 =
    _bindgen_ty_21::lifecycle_msgs__msg__State__TRANSITION_STATE_CONFIGURING;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_21 {
    lifecycle_msgs__msg__State__TRANSITION_STATE_CONFIGURING = 10,
}
pub const lifecycle_msgs__msg__State__TRANSITION_STATE_CLEANINGUP: _bindgen_ty_22 =
    _bindgen_ty_22::lifecycle_msgs__msg__State__TRANSITION_STATE_CLEANINGUP;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_22 {
    lifecycle_msgs__msg__State__TRANSITION_STATE_CLEANINGUP = 11,
}
pub const lifecycle_msgs__msg__State__TRANSITION_STATE_SHUTTINGDOWN: _bindgen_ty_23 =
    _bindgen_ty_23::lifecycle_msgs__msg__State__TRANSITION_STATE_SHUTTINGDOWN;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_23 {
    lifecycle_msgs__msg__State__TRANSITION_STATE_SHUTTINGDOWN = 12,
}
pub const lifecycle_msgs__msg__State__TRANSITION_STATE_ACTIVATING: _bindgen_ty_24 =
    _bindgen_ty_24::lifecycle_msgs__msg__State__TRANSITION_STATE_ACTIVATING;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_24 {
    lifecycle_msgs__msg__State__TRANSITION_STATE_ACTIVATING = 13,
}
pub const lifecycle_msgs__msg__State__TRANSITION_STATE_DEACTIVATING: _bindgen_ty_25 =
    _bindgen_ty_25::lifecycle_msgs__msg__State__TRANSITION_STATE_DEACTIVATING;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_25 {
    lifecycle_msgs__msg__State__TRANSITION_STATE_DEACTIVATING = 14,
}
pub const lifecycle_msgs__msg__State__TRANSITION_STATE_ERRORPROCESSING: _bindgen_ty_26 =
    _bindgen_ty_26::lifecycle_msgs__msg__State__TRANSITION_STATE_ERRORPROCESSING;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_26 {
    lifecycle_msgs__msg__State__TRANSITION_STATE_ERRORPROCESSING = 15,
}
#[repr(C)]
pub struct lifecycle_msgs__msg__State {
    pub id: u8,
    pub label: rosidl_runtime_c__String,
}
#[test]
fn bindgen_test_layout_lifecycle_msgs__msg__State() {
    const UNINIT: ::std::mem::MaybeUninit<lifecycle_msgs__msg__State> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lifecycle_msgs__msg__State>(),
        32usize,
        concat!("Size of: ", stringify!(lifecycle_msgs__msg__State))
    );
    assert_eq!(
        ::std::mem::align_of::<lifecycle_msgs__msg__State>(),
        8usize,
        concat!("Alignment of ", stringify!(lifecycle_msgs__msg__State))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__msg__State),
            "::",
            stringify!(id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).label) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__msg__State),
            "::",
            stringify!(label)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct lifecycle_msgs__msg__State__Sequence {
    pub data: *mut lifecycle_msgs__msg__State,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_lifecycle_msgs__msg__State__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<lifecycle_msgs__msg__State__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lifecycle_msgs__msg__State__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(lifecycle_msgs__msg__State__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<lifecycle_msgs__msg__State__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(lifecycle_msgs__msg__State__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__msg__State__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__msg__State__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__msg__State__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_CREATE: _bindgen_ty_27 =
    _bindgen_ty_27::lifecycle_msgs__msg__Transition__TRANSITION_CREATE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_27 {
    lifecycle_msgs__msg__Transition__TRANSITION_CREATE = 0,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_CONFIGURE: _bindgen_ty_28 =
    _bindgen_ty_28::lifecycle_msgs__msg__Transition__TRANSITION_CONFIGURE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_28 {
    lifecycle_msgs__msg__Transition__TRANSITION_CONFIGURE = 1,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_CLEANUP: _bindgen_ty_29 =
    _bindgen_ty_29::lifecycle_msgs__msg__Transition__TRANSITION_CLEANUP;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_29 {
    lifecycle_msgs__msg__Transition__TRANSITION_CLEANUP = 2,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_ACTIVATE: _bindgen_ty_30 =
    _bindgen_ty_30::lifecycle_msgs__msg__Transition__TRANSITION_ACTIVATE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_30 {
    lifecycle_msgs__msg__Transition__TRANSITION_ACTIVATE = 3,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_DEACTIVATE: _bindgen_ty_31 =
    _bindgen_ty_31::lifecycle_msgs__msg__Transition__TRANSITION_DEACTIVATE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_31 {
    lifecycle_msgs__msg__Transition__TRANSITION_DEACTIVATE = 4,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_UNCONFIGURED_SHUTDOWN: _bindgen_ty_32 =
    _bindgen_ty_32::lifecycle_msgs__msg__Transition__TRANSITION_UNCONFIGURED_SHUTDOWN;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_32 {
    lifecycle_msgs__msg__Transition__TRANSITION_UNCONFIGURED_SHUTDOWN = 5,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_INACTIVE_SHUTDOWN: _bindgen_ty_33 =
    _bindgen_ty_33::lifecycle_msgs__msg__Transition__TRANSITION_INACTIVE_SHUTDOWN;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_33 {
    lifecycle_msgs__msg__Transition__TRANSITION_INACTIVE_SHUTDOWN = 6,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_ACTIVE_SHUTDOWN: _bindgen_ty_34 =
    _bindgen_ty_34::lifecycle_msgs__msg__Transition__TRANSITION_ACTIVE_SHUTDOWN;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_34 {
    lifecycle_msgs__msg__Transition__TRANSITION_ACTIVE_SHUTDOWN = 7,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_DESTROY: _bindgen_ty_35 =
    _bindgen_ty_35::lifecycle_msgs__msg__Transition__TRANSITION_DESTROY;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_35 {
    lifecycle_msgs__msg__Transition__TRANSITION_DESTROY = 8,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_SUCCESS: _bindgen_ty_36 =
    _bindgen_ty_36::lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_SUCCESS;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_36 {
    lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_SUCCESS = 10,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_FAILURE: _bindgen_ty_37 =
    _bindgen_ty_37::lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_FAILURE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_37 {
    lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_FAILURE = 11,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_ERROR: _bindgen_ty_38 =
    _bindgen_ty_38::lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_ERROR;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_38 {
    lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_ERROR = 12,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_SUCCESS: _bindgen_ty_39 =
    _bindgen_ty_39::lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_SUCCESS;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_39 {
    lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_SUCCESS = 20,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_FAILURE: _bindgen_ty_40 =
    _bindgen_ty_40::lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_FAILURE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_40 {
    lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_FAILURE = 21,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_ERROR: _bindgen_ty_41 =
    _bindgen_ty_41::lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_ERROR;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_41 {
    lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_ERROR = 22,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_SUCCESS: _bindgen_ty_42 =
    _bindgen_ty_42::lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_SUCCESS;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_42 {
    lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_SUCCESS = 30,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_FAILURE: _bindgen_ty_43 =
    _bindgen_ty_43::lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_FAILURE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_43 {
    lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_FAILURE = 31,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_ERROR: _bindgen_ty_44 =
    _bindgen_ty_44::lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_ERROR;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_44 {
    lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_ERROR = 32,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_SUCCESS: _bindgen_ty_45 =
    _bindgen_ty_45::lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_SUCCESS;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_45 {
    lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_SUCCESS = 40,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_FAILURE: _bindgen_ty_46 =
    _bindgen_ty_46::lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_FAILURE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_46 {
    lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_FAILURE = 41,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_ERROR: _bindgen_ty_47 =
    _bindgen_ty_47::lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_ERROR;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_47 {
    lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_ERROR = 42,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_SUCCESS: _bindgen_ty_48 =
    _bindgen_ty_48::lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_SUCCESS;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_48 {
    lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_SUCCESS = 50,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_FAILURE: _bindgen_ty_49 =
    _bindgen_ty_49::lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_FAILURE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_49 {
    lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_FAILURE = 51,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_ERROR: _bindgen_ty_50 =
    _bindgen_ty_50::lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_ERROR;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_50 {
    lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_ERROR = 52,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_ON_ERROR_SUCCESS: _bindgen_ty_51 =
    _bindgen_ty_51::lifecycle_msgs__msg__Transition__TRANSITION_ON_ERROR_SUCCESS;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_51 {
    lifecycle_msgs__msg__Transition__TRANSITION_ON_ERROR_SUCCESS = 60,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_ON_ERROR_FAILURE: _bindgen_ty_52 =
    _bindgen_ty_52::lifecycle_msgs__msg__Transition__TRANSITION_ON_ERROR_FAILURE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_52 {
    lifecycle_msgs__msg__Transition__TRANSITION_ON_ERROR_FAILURE = 61,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_ON_ERROR_ERROR: _bindgen_ty_53 =
    _bindgen_ty_53::lifecycle_msgs__msg__Transition__TRANSITION_ON_ERROR_ERROR;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_53 {
    lifecycle_msgs__msg__Transition__TRANSITION_ON_ERROR_ERROR = 62,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS: _bindgen_ty_54 =
    _bindgen_ty_54::lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_54 {
    lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS = 97,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_FAILURE: _bindgen_ty_55 =
    _bindgen_ty_55::lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_FAILURE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_55 {
    lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_FAILURE = 98,
}
pub const lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_ERROR: _bindgen_ty_56 =
    _bindgen_ty_56::lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_ERROR;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_56 {
    lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_ERROR = 99,
}
#[repr(C)]
pub struct lifecycle_msgs__msg__Transition {
    pub id: u8,
    pub label: rosidl_runtime_c__String,
}
#[test]
fn bindgen_test_layout_lifecycle_msgs__msg__Transition() {
    const UNINIT: ::std::mem::MaybeUninit<lifecycle_msgs__msg__Transition> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lifecycle_msgs__msg__Transition>(),
        32usize,
        concat!("Size of: ", stringify!(lifecycle_msgs__msg__Transition))
    );
    assert_eq!(
        ::std::mem::align_of::<lifecycle_msgs__msg__Transition>(),
        8usize,
        concat!("Alignment of ", stringify!(lifecycle_msgs__msg__Transition))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__msg__Transition),
            "::",
            stringify!(id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).label) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__msg__Transition),
            "::",
            stringify!(label)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct lifecycle_msgs__msg__Transition__Sequence {
    pub data: *mut lifecycle_msgs__msg__Transition,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_lifecycle_msgs__msg__Transition__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<lifecycle_msgs__msg__Transition__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lifecycle_msgs__msg__Transition__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(lifecycle_msgs__msg__Transition__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<lifecycle_msgs__msg__Transition__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(lifecycle_msgs__msg__Transition__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__msg__Transition__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__msg__Transition__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__msg__Transition__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct lifecycle_msgs__msg__TransitionDescription {
    pub transition: lifecycle_msgs__msg__Transition,
    pub start_state: lifecycle_msgs__msg__State,
    pub goal_state: lifecycle_msgs__msg__State,
}
#[test]
fn bindgen_test_layout_lifecycle_msgs__msg__TransitionDescription() {
    const UNINIT: ::std::mem::MaybeUninit<lifecycle_msgs__msg__TransitionDescription> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lifecycle_msgs__msg__TransitionDescription>(),
        96usize,
        concat!(
            "Size of: ",
            stringify!(lifecycle_msgs__msg__TransitionDescription)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<lifecycle_msgs__msg__TransitionDescription>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(lifecycle_msgs__msg__TransitionDescription)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).transition) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__msg__TransitionDescription),
            "::",
            stringify!(transition)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).start_state) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__msg__TransitionDescription),
            "::",
            stringify!(start_state)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).goal_state) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__msg__TransitionDescription),
            "::",
            stringify!(goal_state)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct lifecycle_msgs__msg__TransitionDescription__Sequence {
    pub data: *mut lifecycle_msgs__msg__TransitionDescription,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_lifecycle_msgs__msg__TransitionDescription__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<lifecycle_msgs__msg__TransitionDescription__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lifecycle_msgs__msg__TransitionDescription__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(lifecycle_msgs__msg__TransitionDescription__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<lifecycle_msgs__msg__TransitionDescription__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(lifecycle_msgs__msg__TransitionDescription__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__msg__TransitionDescription__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__msg__TransitionDescription__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__msg__TransitionDescription__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct lifecycle_msgs__msg__TransitionEvent {
    pub timestamp: u64,
    pub transition: lifecycle_msgs__msg__Transition,
    pub start_state: lifecycle_msgs__msg__State,
    pub goal_state: lifecycle_msgs__msg__State,
}
#[test]
fn bindgen_test_layout_lifecycle_msgs__msg__TransitionEvent() {
    const UNINIT: ::std::mem::MaybeUninit<lifecycle_msgs__msg__TransitionEvent> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lifecycle_msgs__msg__TransitionEvent>(),
        104usize,
        concat!(
            "Size of: ",
            stringify!(lifecycle_msgs__msg__TransitionEvent)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<lifecycle_msgs__msg__TransitionEvent>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(lifecycle_msgs__msg__TransitionEvent)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__msg__TransitionEvent),
            "::",
            stringify!(timestamp)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).transition) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__msg__TransitionEvent),
            "::",
            stringify!(transition)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).start_state) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__msg__TransitionEvent),
            "::",
            stringify!(start_state)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).goal_state) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__msg__TransitionEvent),
            "::",
            stringify!(goal_state)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct lifecycle_msgs__msg__TransitionEvent__Sequence {
    pub data: *mut lifecycle_msgs__msg__TransitionEvent,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_lifecycle_msgs__msg__TransitionEvent__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<lifecycle_msgs__msg__TransitionEvent__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lifecycle_msgs__msg__TransitionEvent__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(lifecycle_msgs__msg__TransitionEvent__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<lifecycle_msgs__msg__TransitionEvent__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(lifecycle_msgs__msg__TransitionEvent__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__msg__TransitionEvent__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__msg__TransitionEvent__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__msg__TransitionEvent__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct lifecycle_msgs__srv__ChangeState_Request {
    pub transition: lifecycle_msgs__msg__Transition,
}
#[test]
fn bindgen_test_layout_lifecycle_msgs__srv__ChangeState_Request() {
    const UNINIT: ::std::mem::MaybeUninit<lifecycle_msgs__srv__ChangeState_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lifecycle_msgs__srv__ChangeState_Request>(),
        32usize,
        concat!(
            "Size of: ",
            stringify!(lifecycle_msgs__srv__ChangeState_Request)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<lifecycle_msgs__srv__ChangeState_Request>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(lifecycle_msgs__srv__ChangeState_Request)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).transition) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__ChangeState_Request),
            "::",
            stringify!(transition)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct lifecycle_msgs__srv__ChangeState_Request__Sequence {
    pub data: *mut lifecycle_msgs__srv__ChangeState_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_lifecycle_msgs__srv__ChangeState_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<lifecycle_msgs__srv__ChangeState_Request__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lifecycle_msgs__srv__ChangeState_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(lifecycle_msgs__srv__ChangeState_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<lifecycle_msgs__srv__ChangeState_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(lifecycle_msgs__srv__ChangeState_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__ChangeState_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__ChangeState_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__ChangeState_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct lifecycle_msgs__srv__ChangeState_Response {
    pub success: bool,
}
#[test]
fn bindgen_test_layout_lifecycle_msgs__srv__ChangeState_Response() {
    const UNINIT: ::std::mem::MaybeUninit<lifecycle_msgs__srv__ChangeState_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lifecycle_msgs__srv__ChangeState_Response>(),
        1usize,
        concat!(
            "Size of: ",
            stringify!(lifecycle_msgs__srv__ChangeState_Response)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<lifecycle_msgs__srv__ChangeState_Response>(),
        1usize,
        concat!(
            "Alignment of ",
            stringify!(lifecycle_msgs__srv__ChangeState_Response)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).success) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__ChangeState_Response),
            "::",
            stringify!(success)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct lifecycle_msgs__srv__ChangeState_Response__Sequence {
    pub data: *mut lifecycle_msgs__srv__ChangeState_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_lifecycle_msgs__srv__ChangeState_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<lifecycle_msgs__srv__ChangeState_Response__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lifecycle_msgs__srv__ChangeState_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(lifecycle_msgs__srv__ChangeState_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<lifecycle_msgs__srv__ChangeState_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(lifecycle_msgs__srv__ChangeState_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__ChangeState_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__ChangeState_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__ChangeState_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct lifecycle_msgs__srv__GetAvailableStates_Request {
    pub structure_needs_at_least_one_member: u8,
}
#[test]
fn bindgen_test_layout_lifecycle_msgs__srv__GetAvailableStates_Request() {
    const UNINIT: ::std::mem::MaybeUninit<lifecycle_msgs__srv__GetAvailableStates_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lifecycle_msgs__srv__GetAvailableStates_Request>(),
        1usize,
        concat!(
            "Size of: ",
            stringify!(lifecycle_msgs__srv__GetAvailableStates_Request)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<lifecycle_msgs__srv__GetAvailableStates_Request>(),
        1usize,
        concat!(
            "Alignment of ",
            stringify!(lifecycle_msgs__srv__GetAvailableStates_Request)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).structure_needs_at_least_one_member) as usize - ptr as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__GetAvailableStates_Request),
            "::",
            stringify!(structure_needs_at_least_one_member)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct lifecycle_msgs__srv__GetAvailableStates_Request__Sequence {
    pub data: *mut lifecycle_msgs__srv__GetAvailableStates_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_lifecycle_msgs__srv__GetAvailableStates_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        lifecycle_msgs__srv__GetAvailableStates_Request__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lifecycle_msgs__srv__GetAvailableStates_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(lifecycle_msgs__srv__GetAvailableStates_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<lifecycle_msgs__srv__GetAvailableStates_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(lifecycle_msgs__srv__GetAvailableStates_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__GetAvailableStates_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__GetAvailableStates_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__GetAvailableStates_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct lifecycle_msgs__srv__GetAvailableStates_Response {
    pub available_states: lifecycle_msgs__msg__State__Sequence,
}
#[test]
fn bindgen_test_layout_lifecycle_msgs__srv__GetAvailableStates_Response() {
    const UNINIT: ::std::mem::MaybeUninit<lifecycle_msgs__srv__GetAvailableStates_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lifecycle_msgs__srv__GetAvailableStates_Response>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(lifecycle_msgs__srv__GetAvailableStates_Response)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<lifecycle_msgs__srv__GetAvailableStates_Response>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(lifecycle_msgs__srv__GetAvailableStates_Response)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).available_states) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__GetAvailableStates_Response),
            "::",
            stringify!(available_states)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct lifecycle_msgs__srv__GetAvailableStates_Response__Sequence {
    pub data: *mut lifecycle_msgs__srv__GetAvailableStates_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_lifecycle_msgs__srv__GetAvailableStates_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        lifecycle_msgs__srv__GetAvailableStates_Response__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lifecycle_msgs__srv__GetAvailableStates_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(lifecycle_msgs__srv__GetAvailableStates_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<lifecycle_msgs__srv__GetAvailableStates_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(lifecycle_msgs__srv__GetAvailableStates_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__GetAvailableStates_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__GetAvailableStates_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__GetAvailableStates_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct lifecycle_msgs__srv__GetAvailableTransitions_Request {
    pub structure_needs_at_least_one_member: u8,
}
#[test]
fn bindgen_test_layout_lifecycle_msgs__srv__GetAvailableTransitions_Request() {
    const UNINIT: ::std::mem::MaybeUninit<lifecycle_msgs__srv__GetAvailableTransitions_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lifecycle_msgs__srv__GetAvailableTransitions_Request>(),
        1usize,
        concat!(
            "Size of: ",
            stringify!(lifecycle_msgs__srv__GetAvailableTransitions_Request)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<lifecycle_msgs__srv__GetAvailableTransitions_Request>(),
        1usize,
        concat!(
            "Alignment of ",
            stringify!(lifecycle_msgs__srv__GetAvailableTransitions_Request)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).structure_needs_at_least_one_member) as usize - ptr as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__GetAvailableTransitions_Request),
            "::",
            stringify!(structure_needs_at_least_one_member)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct lifecycle_msgs__srv__GetAvailableTransitions_Request__Sequence {
    pub data: *mut lifecycle_msgs__srv__GetAvailableTransitions_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_lifecycle_msgs__srv__GetAvailableTransitions_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        lifecycle_msgs__srv__GetAvailableTransitions_Request__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lifecycle_msgs__srv__GetAvailableTransitions_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(lifecycle_msgs__srv__GetAvailableTransitions_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<lifecycle_msgs__srv__GetAvailableTransitions_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(lifecycle_msgs__srv__GetAvailableTransitions_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__GetAvailableTransitions_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__GetAvailableTransitions_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__GetAvailableTransitions_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct lifecycle_msgs__srv__GetAvailableTransitions_Response {
    pub available_transitions: lifecycle_msgs__msg__TransitionDescription__Sequence,
}
#[test]
fn bindgen_test_layout_lifecycle_msgs__srv__GetAvailableTransitions_Response() {
    const UNINIT: ::std::mem::MaybeUninit<lifecycle_msgs__srv__GetAvailableTransitions_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lifecycle_msgs__srv__GetAvailableTransitions_Response>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(lifecycle_msgs__srv__GetAvailableTransitions_Response)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<lifecycle_msgs__srv__GetAvailableTransitions_Response>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(lifecycle_msgs__srv__GetAvailableTransitions_Response)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).available_transitions) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__GetAvailableTransitions_Response),
            "::",
            stringify!(available_transitions)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct lifecycle_msgs__srv__GetAvailableTransitions_Response__Sequence {
    pub data: *mut lifecycle_msgs__srv__GetAvailableTransitions_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_lifecycle_msgs__srv__GetAvailableTransitions_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        lifecycle_msgs__srv__GetAvailableTransitions_Response__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lifecycle_msgs__srv__GetAvailableTransitions_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(lifecycle_msgs__srv__GetAvailableTransitions_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<lifecycle_msgs__srv__GetAvailableTransitions_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(lifecycle_msgs__srv__GetAvailableTransitions_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__GetAvailableTransitions_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__GetAvailableTransitions_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__GetAvailableTransitions_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct lifecycle_msgs__srv__GetState_Request {
    pub structure_needs_at_least_one_member: u8,
}
#[test]
fn bindgen_test_layout_lifecycle_msgs__srv__GetState_Request() {
    const UNINIT: ::std::mem::MaybeUninit<lifecycle_msgs__srv__GetState_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lifecycle_msgs__srv__GetState_Request>(),
        1usize,
        concat!(
            "Size of: ",
            stringify!(lifecycle_msgs__srv__GetState_Request)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<lifecycle_msgs__srv__GetState_Request>(),
        1usize,
        concat!(
            "Alignment of ",
            stringify!(lifecycle_msgs__srv__GetState_Request)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).structure_needs_at_least_one_member) as usize - ptr as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__GetState_Request),
            "::",
            stringify!(structure_needs_at_least_one_member)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct lifecycle_msgs__srv__GetState_Request__Sequence {
    pub data: *mut lifecycle_msgs__srv__GetState_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_lifecycle_msgs__srv__GetState_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<lifecycle_msgs__srv__GetState_Request__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lifecycle_msgs__srv__GetState_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(lifecycle_msgs__srv__GetState_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<lifecycle_msgs__srv__GetState_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(lifecycle_msgs__srv__GetState_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__GetState_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__GetState_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__GetState_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct lifecycle_msgs__srv__GetState_Response {
    pub current_state: lifecycle_msgs__msg__State,
}
#[test]
fn bindgen_test_layout_lifecycle_msgs__srv__GetState_Response() {
    const UNINIT: ::std::mem::MaybeUninit<lifecycle_msgs__srv__GetState_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lifecycle_msgs__srv__GetState_Response>(),
        32usize,
        concat!(
            "Size of: ",
            stringify!(lifecycle_msgs__srv__GetState_Response)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<lifecycle_msgs__srv__GetState_Response>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(lifecycle_msgs__srv__GetState_Response)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).current_state) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__GetState_Response),
            "::",
            stringify!(current_state)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct lifecycle_msgs__srv__GetState_Response__Sequence {
    pub data: *mut lifecycle_msgs__srv__GetState_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_lifecycle_msgs__srv__GetState_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<lifecycle_msgs__srv__GetState_Response__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<lifecycle_msgs__srv__GetState_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(lifecycle_msgs__srv__GetState_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<lifecycle_msgs__srv__GetState_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(lifecycle_msgs__srv__GetState_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__GetState_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__GetState_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(lifecycle_msgs__srv__GetState_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct nav_msgs__msg__GridCells {
    pub header: std_msgs__msg__Header,
    pub cell_width: f32,
    pub cell_height: f32,
    pub cells: geometry_msgs__msg__Point__Sequence,
}
#[test]
fn bindgen_test_layout_nav_msgs__msg__GridCells() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__msg__GridCells> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__msg__GridCells>(),
        64usize,
        concat!("Size of: ", stringify!(nav_msgs__msg__GridCells))
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__msg__GridCells>(),
        8usize,
        concat!("Alignment of ", stringify!(nav_msgs__msg__GridCells))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__GridCells),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cell_width) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__GridCells),
            "::",
            stringify!(cell_width)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cell_height) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__GridCells),
            "::",
            stringify!(cell_height)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cells) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__GridCells),
            "::",
            stringify!(cells)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct nav_msgs__msg__GridCells__Sequence {
    pub data: *mut nav_msgs__msg__GridCells,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_nav_msgs__msg__GridCells__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__msg__GridCells__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__msg__GridCells__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(nav_msgs__msg__GridCells__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__msg__GridCells__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(nav_msgs__msg__GridCells__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__GridCells__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__GridCells__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__GridCells__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct nav_msgs__msg__MapMetaData {
    pub map_load_time: builtin_interfaces__msg__Time,
    pub resolution: f32,
    pub width: u32,
    pub height: u32,
    pub origin: geometry_msgs__msg__Pose,
}
#[test]
fn bindgen_test_layout_nav_msgs__msg__MapMetaData() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__msg__MapMetaData> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__msg__MapMetaData>(),
        80usize,
        concat!("Size of: ", stringify!(nav_msgs__msg__MapMetaData))
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__msg__MapMetaData>(),
        8usize,
        concat!("Alignment of ", stringify!(nav_msgs__msg__MapMetaData))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).map_load_time) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__MapMetaData),
            "::",
            stringify!(map_load_time)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).resolution) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__MapMetaData),
            "::",
            stringify!(resolution)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__MapMetaData),
            "::",
            stringify!(width)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__MapMetaData),
            "::",
            stringify!(height)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).origin) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__MapMetaData),
            "::",
            stringify!(origin)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct nav_msgs__msg__MapMetaData__Sequence {
    pub data: *mut nav_msgs__msg__MapMetaData,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_nav_msgs__msg__MapMetaData__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__msg__MapMetaData__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__msg__MapMetaData__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(nav_msgs__msg__MapMetaData__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__msg__MapMetaData__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(nav_msgs__msg__MapMetaData__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__MapMetaData__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__MapMetaData__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__MapMetaData__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct nav_msgs__msg__OccupancyGrid {
    pub header: std_msgs__msg__Header,
    pub info: nav_msgs__msg__MapMetaData,
    pub data: rosidl_runtime_c__int8__Sequence,
}
#[test]
fn bindgen_test_layout_nav_msgs__msg__OccupancyGrid() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__msg__OccupancyGrid> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__msg__OccupancyGrid>(),
        136usize,
        concat!("Size of: ", stringify!(nav_msgs__msg__OccupancyGrid))
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__msg__OccupancyGrid>(),
        8usize,
        concat!("Alignment of ", stringify!(nav_msgs__msg__OccupancyGrid))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__OccupancyGrid),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).info) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__OccupancyGrid),
            "::",
            stringify!(info)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__OccupancyGrid),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct nav_msgs__msg__OccupancyGrid__Sequence {
    pub data: *mut nav_msgs__msg__OccupancyGrid,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_nav_msgs__msg__OccupancyGrid__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__msg__OccupancyGrid__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__msg__OccupancyGrid__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(nav_msgs__msg__OccupancyGrid__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__msg__OccupancyGrid__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(nav_msgs__msg__OccupancyGrid__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__OccupancyGrid__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__OccupancyGrid__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__OccupancyGrid__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct nav_msgs__msg__Odometry {
    pub header: std_msgs__msg__Header,
    pub child_frame_id: rosidl_runtime_c__String,
    pub pose: geometry_msgs__msg__PoseWithCovariance,
    pub twist: geometry_msgs__msg__TwistWithCovariance,
}
#[test]
fn bindgen_test_layout_nav_msgs__msg__Odometry() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__msg__Odometry> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__msg__Odometry>(),
        736usize,
        concat!("Size of: ", stringify!(nav_msgs__msg__Odometry))
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__msg__Odometry>(),
        8usize,
        concat!("Alignment of ", stringify!(nav_msgs__msg__Odometry))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__Odometry),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).child_frame_id) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__Odometry),
            "::",
            stringify!(child_frame_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pose) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__Odometry),
            "::",
            stringify!(pose)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).twist) as usize - ptr as usize },
        400usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__Odometry),
            "::",
            stringify!(twist)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct nav_msgs__msg__Odometry__Sequence {
    pub data: *mut nav_msgs__msg__Odometry,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_nav_msgs__msg__Odometry__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__msg__Odometry__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__msg__Odometry__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(nav_msgs__msg__Odometry__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__msg__Odometry__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(nav_msgs__msg__Odometry__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__Odometry__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__Odometry__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__Odometry__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct nav_msgs__msg__Path {
    pub header: std_msgs__msg__Header,
    pub poses: geometry_msgs__msg__PoseStamped__Sequence,
}
#[test]
fn bindgen_test_layout_nav_msgs__msg__Path() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__msg__Path> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__msg__Path>(),
        56usize,
        concat!("Size of: ", stringify!(nav_msgs__msg__Path))
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__msg__Path>(),
        8usize,
        concat!("Alignment of ", stringify!(nav_msgs__msg__Path))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__Path),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).poses) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__Path),
            "::",
            stringify!(poses)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct nav_msgs__msg__Path__Sequence {
    pub data: *mut nav_msgs__msg__Path,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_nav_msgs__msg__Path__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__msg__Path__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__msg__Path__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(nav_msgs__msg__Path__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__msg__Path__Sequence>(),
        8usize,
        concat!("Alignment of ", stringify!(nav_msgs__msg__Path__Sequence))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__Path__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__Path__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__msg__Path__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct nav_msgs__srv__GetMap_Request {
    pub structure_needs_at_least_one_member: u8,
}
#[test]
fn bindgen_test_layout_nav_msgs__srv__GetMap_Request() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__srv__GetMap_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__srv__GetMap_Request>(),
        1usize,
        concat!("Size of: ", stringify!(nav_msgs__srv__GetMap_Request))
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__srv__GetMap_Request>(),
        1usize,
        concat!("Alignment of ", stringify!(nav_msgs__srv__GetMap_Request))
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).structure_needs_at_least_one_member) as usize - ptr as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__GetMap_Request),
            "::",
            stringify!(structure_needs_at_least_one_member)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct nav_msgs__srv__GetMap_Request__Sequence {
    pub data: *mut nav_msgs__srv__GetMap_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_nav_msgs__srv__GetMap_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__srv__GetMap_Request__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__srv__GetMap_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(nav_msgs__srv__GetMap_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__srv__GetMap_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(nav_msgs__srv__GetMap_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__GetMap_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__GetMap_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__GetMap_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct nav_msgs__srv__GetMap_Response {
    pub map: nav_msgs__msg__OccupancyGrid,
}
#[test]
fn bindgen_test_layout_nav_msgs__srv__GetMap_Response() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__srv__GetMap_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__srv__GetMap_Response>(),
        136usize,
        concat!("Size of: ", stringify!(nav_msgs__srv__GetMap_Response))
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__srv__GetMap_Response>(),
        8usize,
        concat!("Alignment of ", stringify!(nav_msgs__srv__GetMap_Response))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).map) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__GetMap_Response),
            "::",
            stringify!(map)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct nav_msgs__srv__GetMap_Response__Sequence {
    pub data: *mut nav_msgs__srv__GetMap_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_nav_msgs__srv__GetMap_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__srv__GetMap_Response__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__srv__GetMap_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(nav_msgs__srv__GetMap_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__srv__GetMap_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(nav_msgs__srv__GetMap_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__GetMap_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__GetMap_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__GetMap_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct nav_msgs__srv__GetPlan_Request {
    pub start: geometry_msgs__msg__PoseStamped,
    pub goal: geometry_msgs__msg__PoseStamped,
    pub tolerance: f32,
}
#[test]
fn bindgen_test_layout_nav_msgs__srv__GetPlan_Request() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__srv__GetPlan_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__srv__GetPlan_Request>(),
        184usize,
        concat!("Size of: ", stringify!(nav_msgs__srv__GetPlan_Request))
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__srv__GetPlan_Request>(),
        8usize,
        concat!("Alignment of ", stringify!(nav_msgs__srv__GetPlan_Request))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).start) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__GetPlan_Request),
            "::",
            stringify!(start)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).goal) as usize - ptr as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__GetPlan_Request),
            "::",
            stringify!(goal)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).tolerance) as usize - ptr as usize },
        176usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__GetPlan_Request),
            "::",
            stringify!(tolerance)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct nav_msgs__srv__GetPlan_Request__Sequence {
    pub data: *mut nav_msgs__srv__GetPlan_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_nav_msgs__srv__GetPlan_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__srv__GetPlan_Request__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__srv__GetPlan_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(nav_msgs__srv__GetPlan_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__srv__GetPlan_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(nav_msgs__srv__GetPlan_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__GetPlan_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__GetPlan_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__GetPlan_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct nav_msgs__srv__GetPlan_Response {
    pub plan: nav_msgs__msg__Path,
}
#[test]
fn bindgen_test_layout_nav_msgs__srv__GetPlan_Response() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__srv__GetPlan_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__srv__GetPlan_Response>(),
        56usize,
        concat!("Size of: ", stringify!(nav_msgs__srv__GetPlan_Response))
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__srv__GetPlan_Response>(),
        8usize,
        concat!("Alignment of ", stringify!(nav_msgs__srv__GetPlan_Response))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).plan) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__GetPlan_Response),
            "::",
            stringify!(plan)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct nav_msgs__srv__GetPlan_Response__Sequence {
    pub data: *mut nav_msgs__srv__GetPlan_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_nav_msgs__srv__GetPlan_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__srv__GetPlan_Response__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__srv__GetPlan_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(nav_msgs__srv__GetPlan_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__srv__GetPlan_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(nav_msgs__srv__GetPlan_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__GetPlan_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__GetPlan_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__GetPlan_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct nav_msgs__srv__LoadMap_Request {
    pub map_url: rosidl_runtime_c__String,
}
#[test]
fn bindgen_test_layout_nav_msgs__srv__LoadMap_Request() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__srv__LoadMap_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__srv__LoadMap_Request>(),
        24usize,
        concat!("Size of: ", stringify!(nav_msgs__srv__LoadMap_Request))
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__srv__LoadMap_Request>(),
        8usize,
        concat!("Alignment of ", stringify!(nav_msgs__srv__LoadMap_Request))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).map_url) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__LoadMap_Request),
            "::",
            stringify!(map_url)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct nav_msgs__srv__LoadMap_Request__Sequence {
    pub data: *mut nav_msgs__srv__LoadMap_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_nav_msgs__srv__LoadMap_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__srv__LoadMap_Request__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__srv__LoadMap_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(nav_msgs__srv__LoadMap_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__srv__LoadMap_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(nav_msgs__srv__LoadMap_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__LoadMap_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__LoadMap_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__LoadMap_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const nav_msgs__srv__LoadMap_Response__RESULT_SUCCESS: _bindgen_ty_57 =
    _bindgen_ty_57::nav_msgs__srv__LoadMap_Response__RESULT_SUCCESS;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_57 {
    nav_msgs__srv__LoadMap_Response__RESULT_SUCCESS = 0,
}
pub const nav_msgs__srv__LoadMap_Response__RESULT_MAP_DOES_NOT_EXIST: _bindgen_ty_58 =
    _bindgen_ty_58::nav_msgs__srv__LoadMap_Response__RESULT_MAP_DOES_NOT_EXIST;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_58 {
    nav_msgs__srv__LoadMap_Response__RESULT_MAP_DOES_NOT_EXIST = 1,
}
pub const nav_msgs__srv__LoadMap_Response__RESULT_INVALID_MAP_DATA: _bindgen_ty_59 =
    _bindgen_ty_59::nav_msgs__srv__LoadMap_Response__RESULT_INVALID_MAP_DATA;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_59 {
    nav_msgs__srv__LoadMap_Response__RESULT_INVALID_MAP_DATA = 2,
}
pub const nav_msgs__srv__LoadMap_Response__RESULT_INVALID_MAP_METADATA: _bindgen_ty_60 =
    _bindgen_ty_60::nav_msgs__srv__LoadMap_Response__RESULT_INVALID_MAP_METADATA;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_60 {
    nav_msgs__srv__LoadMap_Response__RESULT_INVALID_MAP_METADATA = 3,
}
pub const nav_msgs__srv__LoadMap_Response__RESULT_UNDEFINED_FAILURE: _bindgen_ty_61 =
    _bindgen_ty_61::nav_msgs__srv__LoadMap_Response__RESULT_UNDEFINED_FAILURE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_61 {
    nav_msgs__srv__LoadMap_Response__RESULT_UNDEFINED_FAILURE = 255,
}
#[repr(C)]
pub struct nav_msgs__srv__LoadMap_Response {
    pub map: nav_msgs__msg__OccupancyGrid,
    pub result: u8,
}
#[test]
fn bindgen_test_layout_nav_msgs__srv__LoadMap_Response() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__srv__LoadMap_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__srv__LoadMap_Response>(),
        144usize,
        concat!("Size of: ", stringify!(nav_msgs__srv__LoadMap_Response))
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__srv__LoadMap_Response>(),
        8usize,
        concat!("Alignment of ", stringify!(nav_msgs__srv__LoadMap_Response))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).map) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__LoadMap_Response),
            "::",
            stringify!(map)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).result) as usize - ptr as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__LoadMap_Response),
            "::",
            stringify!(result)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct nav_msgs__srv__LoadMap_Response__Sequence {
    pub data: *mut nav_msgs__srv__LoadMap_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_nav_msgs__srv__LoadMap_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__srv__LoadMap_Response__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__srv__LoadMap_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(nav_msgs__srv__LoadMap_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__srv__LoadMap_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(nav_msgs__srv__LoadMap_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__LoadMap_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__LoadMap_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__LoadMap_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct nav_msgs__srv__SetMap_Request {
    pub map: nav_msgs__msg__OccupancyGrid,
    pub initial_pose: geometry_msgs__msg__PoseWithCovarianceStamped,
}
#[test]
fn bindgen_test_layout_nav_msgs__srv__SetMap_Request() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__srv__SetMap_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__srv__SetMap_Request>(),
        512usize,
        concat!("Size of: ", stringify!(nav_msgs__srv__SetMap_Request))
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__srv__SetMap_Request>(),
        8usize,
        concat!("Alignment of ", stringify!(nav_msgs__srv__SetMap_Request))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).map) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__SetMap_Request),
            "::",
            stringify!(map)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).initial_pose) as usize - ptr as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__SetMap_Request),
            "::",
            stringify!(initial_pose)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct nav_msgs__srv__SetMap_Request__Sequence {
    pub data: *mut nav_msgs__srv__SetMap_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_nav_msgs__srv__SetMap_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__srv__SetMap_Request__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__srv__SetMap_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(nav_msgs__srv__SetMap_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__srv__SetMap_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(nav_msgs__srv__SetMap_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__SetMap_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__SetMap_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__SetMap_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct nav_msgs__srv__SetMap_Response {
    pub success: bool,
}
#[test]
fn bindgen_test_layout_nav_msgs__srv__SetMap_Response() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__srv__SetMap_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__srv__SetMap_Response>(),
        1usize,
        concat!("Size of: ", stringify!(nav_msgs__srv__SetMap_Response))
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__srv__SetMap_Response>(),
        1usize,
        concat!("Alignment of ", stringify!(nav_msgs__srv__SetMap_Response))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).success) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__SetMap_Response),
            "::",
            stringify!(success)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct nav_msgs__srv__SetMap_Response__Sequence {
    pub data: *mut nav_msgs__srv__SetMap_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_nav_msgs__srv__SetMap_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<nav_msgs__srv__SetMap_Response__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<nav_msgs__srv__SetMap_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(nav_msgs__srv__SetMap_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<nav_msgs__srv__SetMap_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(nav_msgs__srv__SetMap_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__SetMap_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__SetMap_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(nav_msgs__srv__SetMap_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__msg__FloatingPointRange {
    pub from_value: f64,
    pub to_value: f64,
    pub step: f64,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__msg__FloatingPointRange() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__msg__FloatingPointRange> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__msg__FloatingPointRange>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__msg__FloatingPointRange)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__msg__FloatingPointRange>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__msg__FloatingPointRange)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).from_value) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__FloatingPointRange),
            "::",
            stringify!(from_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).to_value) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__FloatingPointRange),
            "::",
            stringify!(to_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).step) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__FloatingPointRange),
            "::",
            stringify!(step)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__msg__FloatingPointRange__Sequence {
    pub data: *mut rcl_interfaces__msg__FloatingPointRange,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__msg__FloatingPointRange__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__msg__FloatingPointRange__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__msg__FloatingPointRange__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__msg__FloatingPointRange__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__msg__FloatingPointRange__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__msg__FloatingPointRange__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__FloatingPointRange__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__FloatingPointRange__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__FloatingPointRange__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__msg__IntegerRange {
    pub from_value: i64,
    pub to_value: i64,
    pub step: u64,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__msg__IntegerRange() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__msg__IntegerRange> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__msg__IntegerRange>(),
        24usize,
        concat!("Size of: ", stringify!(rcl_interfaces__msg__IntegerRange))
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__msg__IntegerRange>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__msg__IntegerRange)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).from_value) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__IntegerRange),
            "::",
            stringify!(from_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).to_value) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__IntegerRange),
            "::",
            stringify!(to_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).step) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__IntegerRange),
            "::",
            stringify!(step)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__msg__IntegerRange__Sequence {
    pub data: *mut rcl_interfaces__msg__IntegerRange,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__msg__IntegerRange__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__msg__IntegerRange__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__msg__IntegerRange__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__msg__IntegerRange__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__msg__IntegerRange__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__msg__IntegerRange__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__IntegerRange__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__IntegerRange__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__IntegerRange__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct rcl_interfaces__msg__ListParametersResult {
    pub names: rosidl_runtime_c__String__Sequence,
    pub prefixes: rosidl_runtime_c__String__Sequence,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__msg__ListParametersResult() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__msg__ListParametersResult> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__msg__ListParametersResult>(),
        48usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__msg__ListParametersResult)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__msg__ListParametersResult>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__msg__ListParametersResult)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).names) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ListParametersResult),
            "::",
            stringify!(names)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).prefixes) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ListParametersResult),
            "::",
            stringify!(prefixes)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__msg__ListParametersResult__Sequence {
    pub data: *mut rcl_interfaces__msg__ListParametersResult,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__msg__ListParametersResult__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__msg__ListParametersResult__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__msg__ListParametersResult__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__msg__ListParametersResult__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__msg__ListParametersResult__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__msg__ListParametersResult__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ListParametersResult__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ListParametersResult__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ListParametersResult__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const rcl_interfaces__msg__Log__DEBUG: _bindgen_ty_62 =
    _bindgen_ty_62::rcl_interfaces__msg__Log__DEBUG;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_62 {
    rcl_interfaces__msg__Log__DEBUG = 10,
}
pub const rcl_interfaces__msg__Log__INFO: _bindgen_ty_63 =
    _bindgen_ty_63::rcl_interfaces__msg__Log__INFO;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_63 {
    rcl_interfaces__msg__Log__INFO = 20,
}
pub const rcl_interfaces__msg__Log__WARN: _bindgen_ty_64 =
    _bindgen_ty_64::rcl_interfaces__msg__Log__WARN;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_64 {
    rcl_interfaces__msg__Log__WARN = 30,
}
pub const rcl_interfaces__msg__Log__ERROR: _bindgen_ty_65 =
    _bindgen_ty_65::rcl_interfaces__msg__Log__ERROR;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_65 {
    rcl_interfaces__msg__Log__ERROR = 40,
}
pub const rcl_interfaces__msg__Log__FATAL: _bindgen_ty_66 =
    _bindgen_ty_66::rcl_interfaces__msg__Log__FATAL;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_66 {
    rcl_interfaces__msg__Log__FATAL = 50,
}
#[repr(C)]
pub struct rcl_interfaces__msg__Log {
    pub stamp: builtin_interfaces__msg__Time,
    pub level: u8,
    pub name: rosidl_runtime_c__String,
    pub msg: rosidl_runtime_c__String,
    pub file: rosidl_runtime_c__String,
    pub function: rosidl_runtime_c__String,
    pub line: u32,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__msg__Log() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__msg__Log> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__msg__Log>(),
        120usize,
        concat!("Size of: ", stringify!(rcl_interfaces__msg__Log))
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__msg__Log>(),
        8usize,
        concat!("Alignment of ", stringify!(rcl_interfaces__msg__Log))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).stamp) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__Log),
            "::",
            stringify!(stamp)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).level) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__Log),
            "::",
            stringify!(level)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__Log),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).msg) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__Log),
            "::",
            stringify!(msg)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).file) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__Log),
            "::",
            stringify!(file)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).function) as usize - ptr as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__Log),
            "::",
            stringify!(function)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).line) as usize - ptr as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__Log),
            "::",
            stringify!(line)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__msg__Log__Sequence {
    pub data: *mut rcl_interfaces__msg__Log,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__msg__Log__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__msg__Log__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__msg__Log__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(rcl_interfaces__msg__Log__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__msg__Log__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__msg__Log__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__Log__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__Log__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__Log__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct rcl_interfaces__msg__ParameterValue {
    pub type_: u8,
    pub bool_value: bool,
    pub integer_value: i64,
    pub double_value: f64,
    pub string_value: rosidl_runtime_c__String,
    pub byte_array_value: rosidl_runtime_c__octet__Sequence,
    pub bool_array_value: rosidl_runtime_c__boolean__Sequence,
    pub integer_array_value: rosidl_runtime_c__int64__Sequence,
    pub double_array_value: rosidl_runtime_c__double__Sequence,
    pub string_array_value: rosidl_runtime_c__String__Sequence,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__msg__ParameterValue() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__msg__ParameterValue> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__msg__ParameterValue>(),
        168usize,
        concat!("Size of: ", stringify!(rcl_interfaces__msg__ParameterValue))
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__msg__ParameterValue>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__msg__ParameterValue)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterValue),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bool_value) as usize - ptr as usize },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterValue),
            "::",
            stringify!(bool_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).integer_value) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterValue),
            "::",
            stringify!(integer_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).double_value) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterValue),
            "::",
            stringify!(double_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).string_value) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterValue),
            "::",
            stringify!(string_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).byte_array_value) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterValue),
            "::",
            stringify!(byte_array_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bool_array_value) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterValue),
            "::",
            stringify!(bool_array_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).integer_array_value) as usize - ptr as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterValue),
            "::",
            stringify!(integer_array_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).double_array_value) as usize - ptr as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterValue),
            "::",
            stringify!(double_array_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).string_array_value) as usize - ptr as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterValue),
            "::",
            stringify!(string_array_value)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__msg__ParameterValue__Sequence {
    pub data: *mut rcl_interfaces__msg__ParameterValue,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__msg__ParameterValue__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__msg__ParameterValue__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__msg__ParameterValue__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__msg__ParameterValue__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__msg__ParameterValue__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__msg__ParameterValue__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterValue__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterValue__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterValue__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct rcl_interfaces__msg__Parameter {
    pub name: rosidl_runtime_c__String,
    pub value: rcl_interfaces__msg__ParameterValue,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__msg__Parameter() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__msg__Parameter> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__msg__Parameter>(),
        192usize,
        concat!("Size of: ", stringify!(rcl_interfaces__msg__Parameter))
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__msg__Parameter>(),
        8usize,
        concat!("Alignment of ", stringify!(rcl_interfaces__msg__Parameter))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__Parameter),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__Parameter),
            "::",
            stringify!(value)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__msg__Parameter__Sequence {
    pub data: *mut rcl_interfaces__msg__Parameter,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__msg__Parameter__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__msg__Parameter__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__msg__Parameter__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__msg__Parameter__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__msg__Parameter__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__msg__Parameter__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__Parameter__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__Parameter__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__Parameter__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const rcl_interfaces__msg__ParameterDescriptor__floating_point_range__MAX_SIZE: _bindgen_ty_67 =
    _bindgen_ty_67::rcl_interfaces__msg__ParameterDescriptor__floating_point_range__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_67 {
    rcl_interfaces__msg__ParameterDescriptor__floating_point_range__MAX_SIZE = 1,
}
pub const rcl_interfaces__msg__ParameterDescriptor__integer_range__MAX_SIZE: _bindgen_ty_68 =
    _bindgen_ty_68::rcl_interfaces__msg__ParameterDescriptor__integer_range__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_68 {
    rcl_interfaces__msg__ParameterDescriptor__integer_range__MAX_SIZE = 1,
}
#[repr(C)]
pub struct rcl_interfaces__msg__ParameterDescriptor {
    pub name: rosidl_runtime_c__String,
    pub type_: u8,
    pub description: rosidl_runtime_c__String,
    pub additional_constraints: rosidl_runtime_c__String,
    pub read_only: bool,
    pub dynamic_typing: bool,
    pub floating_point_range: rcl_interfaces__msg__FloatingPointRange__Sequence,
    pub integer_range: rcl_interfaces__msg__IntegerRange__Sequence,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__msg__ParameterDescriptor() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__msg__ParameterDescriptor> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__msg__ParameterDescriptor>(),
        136usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__msg__ParameterDescriptor)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__msg__ParameterDescriptor>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__msg__ParameterDescriptor)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterDescriptor),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterDescriptor),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).description) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterDescriptor),
            "::",
            stringify!(description)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).additional_constraints) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterDescriptor),
            "::",
            stringify!(additional_constraints)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).read_only) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterDescriptor),
            "::",
            stringify!(read_only)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dynamic_typing) as usize - ptr as usize },
        81usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterDescriptor),
            "::",
            stringify!(dynamic_typing)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).floating_point_range) as usize - ptr as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterDescriptor),
            "::",
            stringify!(floating_point_range)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).integer_range) as usize - ptr as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterDescriptor),
            "::",
            stringify!(integer_range)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__msg__ParameterDescriptor__Sequence {
    pub data: *mut rcl_interfaces__msg__ParameterDescriptor,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__msg__ParameterDescriptor__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__msg__ParameterDescriptor__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__msg__ParameterDescriptor__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__msg__ParameterDescriptor__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__msg__ParameterDescriptor__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__msg__ParameterDescriptor__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterDescriptor__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterDescriptor__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterDescriptor__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct rcl_interfaces__msg__ParameterEvent {
    pub stamp: builtin_interfaces__msg__Time,
    pub node: rosidl_runtime_c__String,
    pub new_parameters: rcl_interfaces__msg__Parameter__Sequence,
    pub changed_parameters: rcl_interfaces__msg__Parameter__Sequence,
    pub deleted_parameters: rcl_interfaces__msg__Parameter__Sequence,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__msg__ParameterEvent() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__msg__ParameterEvent> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__msg__ParameterEvent>(),
        104usize,
        concat!("Size of: ", stringify!(rcl_interfaces__msg__ParameterEvent))
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__msg__ParameterEvent>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__msg__ParameterEvent)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).stamp) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterEvent),
            "::",
            stringify!(stamp)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).node) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterEvent),
            "::",
            stringify!(node)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).new_parameters) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterEvent),
            "::",
            stringify!(new_parameters)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).changed_parameters) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterEvent),
            "::",
            stringify!(changed_parameters)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).deleted_parameters) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterEvent),
            "::",
            stringify!(deleted_parameters)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__msg__ParameterEvent__Sequence {
    pub data: *mut rcl_interfaces__msg__ParameterEvent,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__msg__ParameterEvent__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__msg__ParameterEvent__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__msg__ParameterEvent__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__msg__ParameterEvent__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__msg__ParameterEvent__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__msg__ParameterEvent__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterEvent__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterEvent__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterEvent__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__msg__ParameterEventDescriptors {
    pub new_parameters: rcl_interfaces__msg__ParameterDescriptor__Sequence,
    pub changed_parameters: rcl_interfaces__msg__ParameterDescriptor__Sequence,
    pub deleted_parameters: rcl_interfaces__msg__ParameterDescriptor__Sequence,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__msg__ParameterEventDescriptors() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__msg__ParameterEventDescriptors> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__msg__ParameterEventDescriptors>(),
        72usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__msg__ParameterEventDescriptors)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__msg__ParameterEventDescriptors>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__msg__ParameterEventDescriptors)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).new_parameters) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterEventDescriptors),
            "::",
            stringify!(new_parameters)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).changed_parameters) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterEventDescriptors),
            "::",
            stringify!(changed_parameters)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).deleted_parameters) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterEventDescriptors),
            "::",
            stringify!(deleted_parameters)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__msg__ParameterEventDescriptors__Sequence {
    pub data: *mut rcl_interfaces__msg__ParameterEventDescriptors,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__msg__ParameterEventDescriptors__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        rcl_interfaces__msg__ParameterEventDescriptors__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__msg__ParameterEventDescriptors__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__msg__ParameterEventDescriptors__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__msg__ParameterEventDescriptors__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__msg__ParameterEventDescriptors__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterEventDescriptors__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterEventDescriptors__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterEventDescriptors__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const rcl_interfaces__msg__ParameterType__PARAMETER_NOT_SET: _bindgen_ty_69 =
    _bindgen_ty_69::rcl_interfaces__msg__ParameterType__PARAMETER_NOT_SET;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_69 {
    rcl_interfaces__msg__ParameterType__PARAMETER_NOT_SET = 0,
}
pub const rcl_interfaces__msg__ParameterType__PARAMETER_BOOL: _bindgen_ty_70 =
    _bindgen_ty_70::rcl_interfaces__msg__ParameterType__PARAMETER_BOOL;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_70 {
    rcl_interfaces__msg__ParameterType__PARAMETER_BOOL = 1,
}
pub const rcl_interfaces__msg__ParameterType__PARAMETER_INTEGER: _bindgen_ty_71 =
    _bindgen_ty_71::rcl_interfaces__msg__ParameterType__PARAMETER_INTEGER;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_71 {
    rcl_interfaces__msg__ParameterType__PARAMETER_INTEGER = 2,
}
pub const rcl_interfaces__msg__ParameterType__PARAMETER_DOUBLE: _bindgen_ty_72 =
    _bindgen_ty_72::rcl_interfaces__msg__ParameterType__PARAMETER_DOUBLE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_72 {
    rcl_interfaces__msg__ParameterType__PARAMETER_DOUBLE = 3,
}
pub const rcl_interfaces__msg__ParameterType__PARAMETER_STRING: _bindgen_ty_73 =
    _bindgen_ty_73::rcl_interfaces__msg__ParameterType__PARAMETER_STRING;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_73 {
    rcl_interfaces__msg__ParameterType__PARAMETER_STRING = 4,
}
pub const rcl_interfaces__msg__ParameterType__PARAMETER_BYTE_ARRAY: _bindgen_ty_74 =
    _bindgen_ty_74::rcl_interfaces__msg__ParameterType__PARAMETER_BYTE_ARRAY;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_74 {
    rcl_interfaces__msg__ParameterType__PARAMETER_BYTE_ARRAY = 5,
}
pub const rcl_interfaces__msg__ParameterType__PARAMETER_BOOL_ARRAY: _bindgen_ty_75 =
    _bindgen_ty_75::rcl_interfaces__msg__ParameterType__PARAMETER_BOOL_ARRAY;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_75 {
    rcl_interfaces__msg__ParameterType__PARAMETER_BOOL_ARRAY = 6,
}
pub const rcl_interfaces__msg__ParameterType__PARAMETER_INTEGER_ARRAY: _bindgen_ty_76 =
    _bindgen_ty_76::rcl_interfaces__msg__ParameterType__PARAMETER_INTEGER_ARRAY;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_76 {
    rcl_interfaces__msg__ParameterType__PARAMETER_INTEGER_ARRAY = 7,
}
pub const rcl_interfaces__msg__ParameterType__PARAMETER_DOUBLE_ARRAY: _bindgen_ty_77 =
    _bindgen_ty_77::rcl_interfaces__msg__ParameterType__PARAMETER_DOUBLE_ARRAY;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_77 {
    rcl_interfaces__msg__ParameterType__PARAMETER_DOUBLE_ARRAY = 8,
}
pub const rcl_interfaces__msg__ParameterType__PARAMETER_STRING_ARRAY: _bindgen_ty_78 =
    _bindgen_ty_78::rcl_interfaces__msg__ParameterType__PARAMETER_STRING_ARRAY;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_78 {
    rcl_interfaces__msg__ParameterType__PARAMETER_STRING_ARRAY = 9,
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__msg__ParameterType {
    pub structure_needs_at_least_one_member: u8,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__msg__ParameterType() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__msg__ParameterType> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__msg__ParameterType>(),
        1usize,
        concat!("Size of: ", stringify!(rcl_interfaces__msg__ParameterType))
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__msg__ParameterType>(),
        1usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__msg__ParameterType)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).structure_needs_at_least_one_member) as usize - ptr as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterType),
            "::",
            stringify!(structure_needs_at_least_one_member)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__msg__ParameterType__Sequence {
    pub data: *mut rcl_interfaces__msg__ParameterType,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__msg__ParameterType__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__msg__ParameterType__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__msg__ParameterType__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__msg__ParameterType__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__msg__ParameterType__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__msg__ParameterType__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterType__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterType__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__ParameterType__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct rcl_interfaces__msg__SetParametersResult {
    pub successful: bool,
    pub reason: rosidl_runtime_c__String,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__msg__SetParametersResult() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__msg__SetParametersResult> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__msg__SetParametersResult>(),
        32usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__msg__SetParametersResult)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__msg__SetParametersResult>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__msg__SetParametersResult)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).successful) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__SetParametersResult),
            "::",
            stringify!(successful)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).reason) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__SetParametersResult),
            "::",
            stringify!(reason)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__msg__SetParametersResult__Sequence {
    pub data: *mut rcl_interfaces__msg__SetParametersResult,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__msg__SetParametersResult__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__msg__SetParametersResult__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__msg__SetParametersResult__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__msg__SetParametersResult__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__msg__SetParametersResult__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__msg__SetParametersResult__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__SetParametersResult__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__SetParametersResult__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__msg__SetParametersResult__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct rcl_interfaces__srv__DescribeParameters_Request {
    pub names: rosidl_runtime_c__String__Sequence,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__srv__DescribeParameters_Request() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__srv__DescribeParameters_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__srv__DescribeParameters_Request>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__srv__DescribeParameters_Request)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__srv__DescribeParameters_Request>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__srv__DescribeParameters_Request)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).names) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__DescribeParameters_Request),
            "::",
            stringify!(names)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__srv__DescribeParameters_Request__Sequence {
    pub data: *mut rcl_interfaces__srv__DescribeParameters_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__srv__DescribeParameters_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        rcl_interfaces__srv__DescribeParameters_Request__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__srv__DescribeParameters_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__srv__DescribeParameters_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__srv__DescribeParameters_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__srv__DescribeParameters_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__DescribeParameters_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__DescribeParameters_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__DescribeParameters_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__srv__DescribeParameters_Response {
    pub descriptors: rcl_interfaces__msg__ParameterDescriptor__Sequence,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__srv__DescribeParameters_Response() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__srv__DescribeParameters_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__srv__DescribeParameters_Response>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__srv__DescribeParameters_Response)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__srv__DescribeParameters_Response>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__srv__DescribeParameters_Response)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).descriptors) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__DescribeParameters_Response),
            "::",
            stringify!(descriptors)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__srv__DescribeParameters_Response__Sequence {
    pub data: *mut rcl_interfaces__srv__DescribeParameters_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__srv__DescribeParameters_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        rcl_interfaces__srv__DescribeParameters_Response__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__srv__DescribeParameters_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__srv__DescribeParameters_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__srv__DescribeParameters_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__srv__DescribeParameters_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__DescribeParameters_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__DescribeParameters_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__DescribeParameters_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct rcl_interfaces__srv__GetParameterTypes_Request {
    pub names: rosidl_runtime_c__String__Sequence,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__srv__GetParameterTypes_Request() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__srv__GetParameterTypes_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__srv__GetParameterTypes_Request>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__srv__GetParameterTypes_Request)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__srv__GetParameterTypes_Request>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__srv__GetParameterTypes_Request)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).names) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__GetParameterTypes_Request),
            "::",
            stringify!(names)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__srv__GetParameterTypes_Request__Sequence {
    pub data: *mut rcl_interfaces__srv__GetParameterTypes_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__srv__GetParameterTypes_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        rcl_interfaces__srv__GetParameterTypes_Request__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__srv__GetParameterTypes_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__srv__GetParameterTypes_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__srv__GetParameterTypes_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__srv__GetParameterTypes_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__GetParameterTypes_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__GetParameterTypes_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__GetParameterTypes_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct rcl_interfaces__srv__GetParameterTypes_Response {
    pub types: rosidl_runtime_c__uint8__Sequence,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__srv__GetParameterTypes_Response() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__srv__GetParameterTypes_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__srv__GetParameterTypes_Response>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__srv__GetParameterTypes_Response)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__srv__GetParameterTypes_Response>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__srv__GetParameterTypes_Response)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).types) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__GetParameterTypes_Response),
            "::",
            stringify!(types)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__srv__GetParameterTypes_Response__Sequence {
    pub data: *mut rcl_interfaces__srv__GetParameterTypes_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__srv__GetParameterTypes_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        rcl_interfaces__srv__GetParameterTypes_Response__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__srv__GetParameterTypes_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__srv__GetParameterTypes_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__srv__GetParameterTypes_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__srv__GetParameterTypes_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__GetParameterTypes_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__GetParameterTypes_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__GetParameterTypes_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct rcl_interfaces__srv__GetParameters_Request {
    pub names: rosidl_runtime_c__String__Sequence,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__srv__GetParameters_Request() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__srv__GetParameters_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__srv__GetParameters_Request>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__srv__GetParameters_Request)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__srv__GetParameters_Request>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__srv__GetParameters_Request)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).names) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__GetParameters_Request),
            "::",
            stringify!(names)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__srv__GetParameters_Request__Sequence {
    pub data: *mut rcl_interfaces__srv__GetParameters_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__srv__GetParameters_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__srv__GetParameters_Request__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__srv__GetParameters_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__srv__GetParameters_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__srv__GetParameters_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__srv__GetParameters_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__GetParameters_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__GetParameters_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__GetParameters_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__srv__GetParameters_Response {
    pub values: rcl_interfaces__msg__ParameterValue__Sequence,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__srv__GetParameters_Response() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__srv__GetParameters_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__srv__GetParameters_Response>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__srv__GetParameters_Response)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__srv__GetParameters_Response>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__srv__GetParameters_Response)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).values) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__GetParameters_Response),
            "::",
            stringify!(values)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__srv__GetParameters_Response__Sequence {
    pub data: *mut rcl_interfaces__srv__GetParameters_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__srv__GetParameters_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__srv__GetParameters_Response__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__srv__GetParameters_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__srv__GetParameters_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__srv__GetParameters_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__srv__GetParameters_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__GetParameters_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__GetParameters_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__GetParameters_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const rcl_interfaces__srv__ListParameters_Request__DEPTH_RECURSIVE: _bindgen_ty_79 =
    _bindgen_ty_79::rcl_interfaces__srv__ListParameters_Request__DEPTH_RECURSIVE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_79 {
    rcl_interfaces__srv__ListParameters_Request__DEPTH_RECURSIVE = 0,
}
#[repr(C)]
pub struct rcl_interfaces__srv__ListParameters_Request {
    pub prefixes: rosidl_runtime_c__String__Sequence,
    pub depth: u64,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__srv__ListParameters_Request() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__srv__ListParameters_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__srv__ListParameters_Request>(),
        32usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__srv__ListParameters_Request)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__srv__ListParameters_Request>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__srv__ListParameters_Request)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).prefixes) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__ListParameters_Request),
            "::",
            stringify!(prefixes)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).depth) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__ListParameters_Request),
            "::",
            stringify!(depth)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__srv__ListParameters_Request__Sequence {
    pub data: *mut rcl_interfaces__srv__ListParameters_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__srv__ListParameters_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__srv__ListParameters_Request__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__srv__ListParameters_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__srv__ListParameters_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__srv__ListParameters_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__srv__ListParameters_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__ListParameters_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__ListParameters_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__ListParameters_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct rcl_interfaces__srv__ListParameters_Response {
    pub result: rcl_interfaces__msg__ListParametersResult,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__srv__ListParameters_Response() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__srv__ListParameters_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__srv__ListParameters_Response>(),
        48usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__srv__ListParameters_Response)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__srv__ListParameters_Response>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__srv__ListParameters_Response)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).result) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__ListParameters_Response),
            "::",
            stringify!(result)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__srv__ListParameters_Response__Sequence {
    pub data: *mut rcl_interfaces__srv__ListParameters_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__srv__ListParameters_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__srv__ListParameters_Response__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__srv__ListParameters_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__srv__ListParameters_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__srv__ListParameters_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__srv__ListParameters_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__ListParameters_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__ListParameters_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__ListParameters_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__srv__SetParameters_Request {
    pub parameters: rcl_interfaces__msg__Parameter__Sequence,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__srv__SetParameters_Request() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__srv__SetParameters_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__srv__SetParameters_Request>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__srv__SetParameters_Request)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__srv__SetParameters_Request>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__srv__SetParameters_Request)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).parameters) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__SetParameters_Request),
            "::",
            stringify!(parameters)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__srv__SetParameters_Request__Sequence {
    pub data: *mut rcl_interfaces__srv__SetParameters_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__srv__SetParameters_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__srv__SetParameters_Request__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__srv__SetParameters_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__srv__SetParameters_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__srv__SetParameters_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__srv__SetParameters_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__SetParameters_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__SetParameters_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__SetParameters_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__srv__SetParameters_Response {
    pub results: rcl_interfaces__msg__SetParametersResult__Sequence,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__srv__SetParameters_Response() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__srv__SetParameters_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__srv__SetParameters_Response>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__srv__SetParameters_Response)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__srv__SetParameters_Response>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__srv__SetParameters_Response)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).results) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__SetParameters_Response),
            "::",
            stringify!(results)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__srv__SetParameters_Response__Sequence {
    pub data: *mut rcl_interfaces__srv__SetParameters_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__srv__SetParameters_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__srv__SetParameters_Response__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__srv__SetParameters_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__srv__SetParameters_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__srv__SetParameters_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__srv__SetParameters_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__SetParameters_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__SetParameters_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__SetParameters_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__srv__SetParametersAtomically_Request {
    pub parameters: rcl_interfaces__msg__Parameter__Sequence,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__srv__SetParametersAtomically_Request() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__srv__SetParametersAtomically_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__srv__SetParametersAtomically_Request>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__srv__SetParametersAtomically_Request)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__srv__SetParametersAtomically_Request>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__srv__SetParametersAtomically_Request)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).parameters) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__SetParametersAtomically_Request),
            "::",
            stringify!(parameters)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__srv__SetParametersAtomically_Request__Sequence {
    pub data: *mut rcl_interfaces__srv__SetParametersAtomically_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__srv__SetParametersAtomically_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        rcl_interfaces__srv__SetParametersAtomically_Request__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__srv__SetParametersAtomically_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__srv__SetParametersAtomically_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__srv__SetParametersAtomically_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__srv__SetParametersAtomically_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__SetParametersAtomically_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__SetParametersAtomically_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__SetParametersAtomically_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct rcl_interfaces__srv__SetParametersAtomically_Response {
    pub result: rcl_interfaces__msg__SetParametersResult,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__srv__SetParametersAtomically_Response() {
    const UNINIT: ::std::mem::MaybeUninit<rcl_interfaces__srv__SetParametersAtomically_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__srv__SetParametersAtomically_Response>(),
        32usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__srv__SetParametersAtomically_Response)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__srv__SetParametersAtomically_Response>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__srv__SetParametersAtomically_Response)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).result) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__SetParametersAtomically_Response),
            "::",
            stringify!(result)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rcl_interfaces__srv__SetParametersAtomically_Response__Sequence {
    pub data: *mut rcl_interfaces__srv__SetParametersAtomically_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rcl_interfaces__srv__SetParametersAtomically_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        rcl_interfaces__srv__SetParametersAtomically_Response__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rcl_interfaces__srv__SetParametersAtomically_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(rcl_interfaces__srv__SetParametersAtomically_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<rcl_interfaces__srv__SetParametersAtomically_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rcl_interfaces__srv__SetParametersAtomically_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__SetParametersAtomically_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__SetParametersAtomically_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rcl_interfaces__srv__SetParametersAtomically_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rosgraph_msgs__msg__Clock {
    pub clock: builtin_interfaces__msg__Time,
}
#[test]
fn bindgen_test_layout_rosgraph_msgs__msg__Clock() {
    const UNINIT: ::std::mem::MaybeUninit<rosgraph_msgs__msg__Clock> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rosgraph_msgs__msg__Clock>(),
        8usize,
        concat!("Size of: ", stringify!(rosgraph_msgs__msg__Clock))
    );
    assert_eq!(
        ::std::mem::align_of::<rosgraph_msgs__msg__Clock>(),
        4usize,
        concat!("Alignment of ", stringify!(rosgraph_msgs__msg__Clock))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).clock) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rosgraph_msgs__msg__Clock),
            "::",
            stringify!(clock)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct rosgraph_msgs__msg__Clock__Sequence {
    pub data: *mut rosgraph_msgs__msg__Clock,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_rosgraph_msgs__msg__Clock__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<rosgraph_msgs__msg__Clock__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<rosgraph_msgs__msg__Clock__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(rosgraph_msgs__msg__Clock__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<rosgraph_msgs__msg__Clock__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rosgraph_msgs__msg__Clock__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rosgraph_msgs__msg__Clock__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(rosgraph_msgs__msg__Clock__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(rosgraph_msgs__msg__Clock__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const sensor_msgs__msg__BatteryState__POWER_SUPPLY_STATUS_UNKNOWN: _bindgen_ty_80 =
    _bindgen_ty_80::sensor_msgs__msg__BatteryState__POWER_SUPPLY_STATUS_UNKNOWN;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_80 {
    sensor_msgs__msg__BatteryState__POWER_SUPPLY_STATUS_UNKNOWN = 0,
}
pub const sensor_msgs__msg__BatteryState__POWER_SUPPLY_STATUS_CHARGING: _bindgen_ty_81 =
    _bindgen_ty_81::sensor_msgs__msg__BatteryState__POWER_SUPPLY_STATUS_CHARGING;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_81 {
    sensor_msgs__msg__BatteryState__POWER_SUPPLY_STATUS_CHARGING = 1,
}
pub const sensor_msgs__msg__BatteryState__POWER_SUPPLY_STATUS_DISCHARGING: _bindgen_ty_82 =
    _bindgen_ty_82::sensor_msgs__msg__BatteryState__POWER_SUPPLY_STATUS_DISCHARGING;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_82 {
    sensor_msgs__msg__BatteryState__POWER_SUPPLY_STATUS_DISCHARGING = 2,
}
pub const sensor_msgs__msg__BatteryState__POWER_SUPPLY_STATUS_NOT_CHARGING: _bindgen_ty_83 =
    _bindgen_ty_83::sensor_msgs__msg__BatteryState__POWER_SUPPLY_STATUS_NOT_CHARGING;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_83 {
    sensor_msgs__msg__BatteryState__POWER_SUPPLY_STATUS_NOT_CHARGING = 3,
}
pub const sensor_msgs__msg__BatteryState__POWER_SUPPLY_STATUS_FULL: _bindgen_ty_84 =
    _bindgen_ty_84::sensor_msgs__msg__BatteryState__POWER_SUPPLY_STATUS_FULL;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_84 {
    sensor_msgs__msg__BatteryState__POWER_SUPPLY_STATUS_FULL = 4,
}
pub const sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_UNKNOWN: _bindgen_ty_85 =
    _bindgen_ty_85::sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_UNKNOWN;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_85 {
    sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_UNKNOWN = 0,
}
pub const sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_GOOD: _bindgen_ty_86 =
    _bindgen_ty_86::sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_GOOD;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_86 {
    sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_GOOD = 1,
}
pub const sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_OVERHEAT: _bindgen_ty_87 =
    _bindgen_ty_87::sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_OVERHEAT;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_87 {
    sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_OVERHEAT = 2,
}
pub const sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_DEAD: _bindgen_ty_88 =
    _bindgen_ty_88::sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_DEAD;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_88 {
    sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_DEAD = 3,
}
pub const sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_OVERVOLTAGE: _bindgen_ty_89 =
    _bindgen_ty_89::sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_OVERVOLTAGE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_89 {
    sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_OVERVOLTAGE = 4,
}
pub const sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_UNSPEC_FAILURE: _bindgen_ty_90 =
    _bindgen_ty_90::sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_90 {
    sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_UNSPEC_FAILURE = 5,
}
pub const sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_COLD: _bindgen_ty_91 =
    _bindgen_ty_91::sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_COLD;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_91 {
    sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_COLD = 6,
}
pub const sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE:
    _bindgen_ty_92 =
    _bindgen_ty_92::sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_92 {
    sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE = 7,
}
pub const sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE: _bindgen_ty_93 =
    _bindgen_ty_93::sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_93 {
    sensor_msgs__msg__BatteryState__POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE = 8,
}
pub const sensor_msgs__msg__BatteryState__POWER_SUPPLY_TECHNOLOGY_UNKNOWN: _bindgen_ty_94 =
    _bindgen_ty_94::sensor_msgs__msg__BatteryState__POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_94 {
    sensor_msgs__msg__BatteryState__POWER_SUPPLY_TECHNOLOGY_UNKNOWN = 0,
}
pub const sensor_msgs__msg__BatteryState__POWER_SUPPLY_TECHNOLOGY_NIMH: _bindgen_ty_95 =
    _bindgen_ty_95::sensor_msgs__msg__BatteryState__POWER_SUPPLY_TECHNOLOGY_NIMH;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_95 {
    sensor_msgs__msg__BatteryState__POWER_SUPPLY_TECHNOLOGY_NIMH = 1,
}
pub const sensor_msgs__msg__BatteryState__POWER_SUPPLY_TECHNOLOGY_LION: _bindgen_ty_96 =
    _bindgen_ty_96::sensor_msgs__msg__BatteryState__POWER_SUPPLY_TECHNOLOGY_LION;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_96 {
    sensor_msgs__msg__BatteryState__POWER_SUPPLY_TECHNOLOGY_LION = 2,
}
pub const sensor_msgs__msg__BatteryState__POWER_SUPPLY_TECHNOLOGY_LIPO: _bindgen_ty_97 =
    _bindgen_ty_97::sensor_msgs__msg__BatteryState__POWER_SUPPLY_TECHNOLOGY_LIPO;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_97 {
    sensor_msgs__msg__BatteryState__POWER_SUPPLY_TECHNOLOGY_LIPO = 3,
}
pub const sensor_msgs__msg__BatteryState__POWER_SUPPLY_TECHNOLOGY_LIFE: _bindgen_ty_98 =
    _bindgen_ty_98::sensor_msgs__msg__BatteryState__POWER_SUPPLY_TECHNOLOGY_LIFE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_98 {
    sensor_msgs__msg__BatteryState__POWER_SUPPLY_TECHNOLOGY_LIFE = 4,
}
pub const sensor_msgs__msg__BatteryState__POWER_SUPPLY_TECHNOLOGY_NICD: _bindgen_ty_99 =
    _bindgen_ty_99::sensor_msgs__msg__BatteryState__POWER_SUPPLY_TECHNOLOGY_NICD;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_99 {
    sensor_msgs__msg__BatteryState__POWER_SUPPLY_TECHNOLOGY_NICD = 5,
}
pub const sensor_msgs__msg__BatteryState__POWER_SUPPLY_TECHNOLOGY_LIMN: _bindgen_ty_100 =
    _bindgen_ty_100::sensor_msgs__msg__BatteryState__POWER_SUPPLY_TECHNOLOGY_LIMN;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_100 {
    sensor_msgs__msg__BatteryState__POWER_SUPPLY_TECHNOLOGY_LIMN = 6,
}
#[repr(C)]
pub struct sensor_msgs__msg__BatteryState {
    pub header: std_msgs__msg__Header,
    pub voltage: f32,
    pub temperature: f32,
    pub current: f32,
    pub charge: f32,
    pub capacity: f32,
    pub design_capacity: f32,
    pub percentage: f32,
    pub power_supply_status: u8,
    pub power_supply_health: u8,
    pub power_supply_technology: u8,
    pub present: bool,
    pub cell_voltage: rosidl_runtime_c__float__Sequence,
    pub cell_temperature: rosidl_runtime_c__float__Sequence,
    pub location: rosidl_runtime_c__String,
    pub serial_number: rosidl_runtime_c__String,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__BatteryState() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__BatteryState> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__BatteryState>(),
        160usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__BatteryState))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__BatteryState>(),
        8usize,
        concat!("Alignment of ", stringify!(sensor_msgs__msg__BatteryState))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__BatteryState),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).voltage) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__BatteryState),
            "::",
            stringify!(voltage)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).temperature) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__BatteryState),
            "::",
            stringify!(temperature)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).current) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__BatteryState),
            "::",
            stringify!(current)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).charge) as usize - ptr as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__BatteryState),
            "::",
            stringify!(charge)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__BatteryState),
            "::",
            stringify!(capacity)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).design_capacity) as usize - ptr as usize },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__BatteryState),
            "::",
            stringify!(design_capacity)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).percentage) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__BatteryState),
            "::",
            stringify!(percentage)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).power_supply_status) as usize - ptr as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__BatteryState),
            "::",
            stringify!(power_supply_status)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).power_supply_health) as usize - ptr as usize },
        61usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__BatteryState),
            "::",
            stringify!(power_supply_health)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).power_supply_technology) as usize - ptr as usize },
        62usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__BatteryState),
            "::",
            stringify!(power_supply_technology)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).present) as usize - ptr as usize },
        63usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__BatteryState),
            "::",
            stringify!(present)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cell_voltage) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__BatteryState),
            "::",
            stringify!(cell_voltage)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cell_temperature) as usize - ptr as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__BatteryState),
            "::",
            stringify!(cell_temperature)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).location) as usize - ptr as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__BatteryState),
            "::",
            stringify!(location)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).serial_number) as usize - ptr as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__BatteryState),
            "::",
            stringify!(serial_number)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__BatteryState__Sequence {
    pub data: *mut sensor_msgs__msg__BatteryState,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__BatteryState__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__BatteryState__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__BatteryState__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__msg__BatteryState__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__BatteryState__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__BatteryState__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__BatteryState__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__BatteryState__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__BatteryState__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__RegionOfInterest {
    pub x_offset: u32,
    pub y_offset: u32,
    pub height: u32,
    pub width: u32,
    pub do_rectify: bool,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__RegionOfInterest() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__RegionOfInterest> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__RegionOfInterest>(),
        20usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__RegionOfInterest))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__RegionOfInterest>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__RegionOfInterest)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).x_offset) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__RegionOfInterest),
            "::",
            stringify!(x_offset)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).y_offset) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__RegionOfInterest),
            "::",
            stringify!(y_offset)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__RegionOfInterest),
            "::",
            stringify!(height)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__RegionOfInterest),
            "::",
            stringify!(width)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).do_rectify) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__RegionOfInterest),
            "::",
            stringify!(do_rectify)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__RegionOfInterest__Sequence {
    pub data: *mut sensor_msgs__msg__RegionOfInterest,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__RegionOfInterest__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__RegionOfInterest__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__RegionOfInterest__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__msg__RegionOfInterest__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__RegionOfInterest__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__RegionOfInterest__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__RegionOfInterest__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__RegionOfInterest__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__RegionOfInterest__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct sensor_msgs__msg__CameraInfo {
    pub header: std_msgs__msg__Header,
    pub height: u32,
    pub width: u32,
    pub distortion_model: rosidl_runtime_c__String,
    pub d: rosidl_runtime_c__double__Sequence,
    pub k: [f64; 9usize],
    pub r: [f64; 9usize],
    pub p: [f64; 12usize],
    pub binning_x: u32,
    pub binning_y: u32,
    pub roi: sensor_msgs__msg__RegionOfInterest,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__CameraInfo() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__CameraInfo> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__CameraInfo>(),
        360usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__CameraInfo))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__CameraInfo>(),
        8usize,
        concat!("Alignment of ", stringify!(sensor_msgs__msg__CameraInfo))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__CameraInfo),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__CameraInfo),
            "::",
            stringify!(height)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__CameraInfo),
            "::",
            stringify!(width)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).distortion_model) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__CameraInfo),
            "::",
            stringify!(distortion_model)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__CameraInfo),
            "::",
            stringify!(d)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).k) as usize - ptr as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__CameraInfo),
            "::",
            stringify!(k)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
        160usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__CameraInfo),
            "::",
            stringify!(r)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).p) as usize - ptr as usize },
        232usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__CameraInfo),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).binning_x) as usize - ptr as usize },
        328usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__CameraInfo),
            "::",
            stringify!(binning_x)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).binning_y) as usize - ptr as usize },
        332usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__CameraInfo),
            "::",
            stringify!(binning_y)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).roi) as usize - ptr as usize },
        336usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__CameraInfo),
            "::",
            stringify!(roi)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__CameraInfo__Sequence {
    pub data: *mut sensor_msgs__msg__CameraInfo,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__CameraInfo__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__CameraInfo__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__CameraInfo__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__msg__CameraInfo__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__CameraInfo__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__CameraInfo__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__CameraInfo__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__CameraInfo__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__CameraInfo__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct sensor_msgs__msg__ChannelFloat32 {
    pub name: rosidl_runtime_c__String,
    pub values: rosidl_runtime_c__float__Sequence,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__ChannelFloat32() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__ChannelFloat32> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__ChannelFloat32>(),
        48usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__ChannelFloat32))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__ChannelFloat32>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__ChannelFloat32)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__ChannelFloat32),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).values) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__ChannelFloat32),
            "::",
            stringify!(values)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__ChannelFloat32__Sequence {
    pub data: *mut sensor_msgs__msg__ChannelFloat32,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__ChannelFloat32__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__ChannelFloat32__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__ChannelFloat32__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__msg__ChannelFloat32__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__ChannelFloat32__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__ChannelFloat32__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__ChannelFloat32__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__ChannelFloat32__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__ChannelFloat32__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct sensor_msgs__msg__CompressedImage {
    pub header: std_msgs__msg__Header,
    pub format: rosidl_runtime_c__String,
    pub data: rosidl_runtime_c__uint8__Sequence,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__CompressedImage() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__CompressedImage> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__CompressedImage>(),
        80usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__CompressedImage))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__CompressedImage>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__CompressedImage)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__CompressedImage),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__CompressedImage),
            "::",
            stringify!(format)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__CompressedImage),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__CompressedImage__Sequence {
    pub data: *mut sensor_msgs__msg__CompressedImage,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__CompressedImage__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__CompressedImage__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__CompressedImage__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__msg__CompressedImage__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__CompressedImage__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__CompressedImage__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__CompressedImage__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__CompressedImage__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__CompressedImage__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct sensor_msgs__msg__FluidPressure {
    pub header: std_msgs__msg__Header,
    pub fluid_pressure: f64,
    pub variance: f64,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__FluidPressure() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__FluidPressure> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__FluidPressure>(),
        48usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__FluidPressure))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__FluidPressure>(),
        8usize,
        concat!("Alignment of ", stringify!(sensor_msgs__msg__FluidPressure))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__FluidPressure),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fluid_pressure) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__FluidPressure),
            "::",
            stringify!(fluid_pressure)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).variance) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__FluidPressure),
            "::",
            stringify!(variance)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__FluidPressure__Sequence {
    pub data: *mut sensor_msgs__msg__FluidPressure,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__FluidPressure__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__FluidPressure__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__FluidPressure__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__msg__FluidPressure__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__FluidPressure__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__FluidPressure__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__FluidPressure__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__FluidPressure__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__FluidPressure__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct sensor_msgs__msg__Illuminance {
    pub header: std_msgs__msg__Header,
    pub illuminance: f64,
    pub variance: f64,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__Illuminance() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__Illuminance> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__Illuminance>(),
        48usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__Illuminance))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__Illuminance>(),
        8usize,
        concat!("Alignment of ", stringify!(sensor_msgs__msg__Illuminance))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Illuminance),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).illuminance) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Illuminance),
            "::",
            stringify!(illuminance)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).variance) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Illuminance),
            "::",
            stringify!(variance)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__Illuminance__Sequence {
    pub data: *mut sensor_msgs__msg__Illuminance,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__Illuminance__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__Illuminance__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__Illuminance__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__msg__Illuminance__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__Illuminance__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__Illuminance__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Illuminance__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Illuminance__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Illuminance__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct sensor_msgs__msg__Image {
    pub header: std_msgs__msg__Header,
    pub height: u32,
    pub width: u32,
    pub encoding: rosidl_runtime_c__String,
    pub is_bigendian: u8,
    pub step: u32,
    pub data: rosidl_runtime_c__uint8__Sequence,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__Image() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__Image> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__Image>(),
        96usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__Image))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__Image>(),
        8usize,
        concat!("Alignment of ", stringify!(sensor_msgs__msg__Image))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Image),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Image),
            "::",
            stringify!(height)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Image),
            "::",
            stringify!(width)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).encoding) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Image),
            "::",
            stringify!(encoding)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).is_bigendian) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Image),
            "::",
            stringify!(is_bigendian)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).step) as usize - ptr as usize },
        68usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Image),
            "::",
            stringify!(step)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Image),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__Image__Sequence {
    pub data: *mut sensor_msgs__msg__Image,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__Image__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__Image__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__Image__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__Image__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__Image__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__Image__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Image__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Image__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Image__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct sensor_msgs__msg__Imu {
    pub header: std_msgs__msg__Header,
    pub orientation: geometry_msgs__msg__Quaternion,
    pub orientation_covariance: [f64; 9usize],
    pub angular_velocity: geometry_msgs__msg__Vector3,
    pub angular_velocity_covariance: [f64; 9usize],
    pub linear_acceleration: geometry_msgs__msg__Vector3,
    pub linear_acceleration_covariance: [f64; 9usize],
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__Imu() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__Imu> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__Imu>(),
        328usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__Imu))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__Imu>(),
        8usize,
        concat!("Alignment of ", stringify!(sensor_msgs__msg__Imu))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Imu),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).orientation) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Imu),
            "::",
            stringify!(orientation)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).orientation_covariance) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Imu),
            "::",
            stringify!(orientation_covariance)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).angular_velocity) as usize - ptr as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Imu),
            "::",
            stringify!(angular_velocity)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).angular_velocity_covariance) as usize - ptr as usize },
        160usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Imu),
            "::",
            stringify!(angular_velocity_covariance)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).linear_acceleration) as usize - ptr as usize },
        232usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Imu),
            "::",
            stringify!(linear_acceleration)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).linear_acceleration_covariance) as usize - ptr as usize
        },
        256usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Imu),
            "::",
            stringify!(linear_acceleration_covariance)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__Imu__Sequence {
    pub data: *mut sensor_msgs__msg__Imu,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__Imu__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__Imu__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__Imu__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__Imu__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__Imu__Sequence>(),
        8usize,
        concat!("Alignment of ", stringify!(sensor_msgs__msg__Imu__Sequence))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Imu__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Imu__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Imu__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct sensor_msgs__msg__JointState {
    pub header: std_msgs__msg__Header,
    pub name: rosidl_runtime_c__String__Sequence,
    pub position: rosidl_runtime_c__double__Sequence,
    pub velocity: rosidl_runtime_c__double__Sequence,
    pub effort: rosidl_runtime_c__double__Sequence,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__JointState() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__JointState> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__JointState>(),
        128usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__JointState))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__JointState>(),
        8usize,
        concat!("Alignment of ", stringify!(sensor_msgs__msg__JointState))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__JointState),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__JointState),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).position) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__JointState),
            "::",
            stringify!(position)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).velocity) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__JointState),
            "::",
            stringify!(velocity)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).effort) as usize - ptr as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__JointState),
            "::",
            stringify!(effort)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__JointState__Sequence {
    pub data: *mut sensor_msgs__msg__JointState,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__JointState__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__JointState__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__JointState__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__msg__JointState__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__JointState__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__JointState__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__JointState__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__JointState__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__JointState__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct sensor_msgs__msg__Joy {
    pub header: std_msgs__msg__Header,
    pub axes: rosidl_runtime_c__float__Sequence,
    pub buttons: rosidl_runtime_c__int32__Sequence,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__Joy() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__Joy> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__Joy>(),
        80usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__Joy))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__Joy>(),
        8usize,
        concat!("Alignment of ", stringify!(sensor_msgs__msg__Joy))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Joy),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).axes) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Joy),
            "::",
            stringify!(axes)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).buttons) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Joy),
            "::",
            stringify!(buttons)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__Joy__Sequence {
    pub data: *mut sensor_msgs__msg__Joy,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__Joy__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__Joy__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__Joy__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__Joy__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__Joy__Sequence>(),
        8usize,
        concat!("Alignment of ", stringify!(sensor_msgs__msg__Joy__Sequence))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Joy__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Joy__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Joy__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const sensor_msgs__msg__JoyFeedback__TYPE_LED: _bindgen_ty_101 =
    _bindgen_ty_101::sensor_msgs__msg__JoyFeedback__TYPE_LED;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_101 {
    sensor_msgs__msg__JoyFeedback__TYPE_LED = 0,
}
pub const sensor_msgs__msg__JoyFeedback__TYPE_RUMBLE: _bindgen_ty_102 =
    _bindgen_ty_102::sensor_msgs__msg__JoyFeedback__TYPE_RUMBLE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_102 {
    sensor_msgs__msg__JoyFeedback__TYPE_RUMBLE = 1,
}
pub const sensor_msgs__msg__JoyFeedback__TYPE_BUZZER: _bindgen_ty_103 =
    _bindgen_ty_103::sensor_msgs__msg__JoyFeedback__TYPE_BUZZER;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_103 {
    sensor_msgs__msg__JoyFeedback__TYPE_BUZZER = 2,
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__JoyFeedback {
    pub type_: u8,
    pub id: u8,
    pub intensity: f32,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__JoyFeedback() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__JoyFeedback> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__JoyFeedback>(),
        8usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__JoyFeedback))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__JoyFeedback>(),
        4usize,
        concat!("Alignment of ", stringify!(sensor_msgs__msg__JoyFeedback))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__JoyFeedback),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__JoyFeedback),
            "::",
            stringify!(id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).intensity) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__JoyFeedback),
            "::",
            stringify!(intensity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__JoyFeedback__Sequence {
    pub data: *mut sensor_msgs__msg__JoyFeedback,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__JoyFeedback__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__JoyFeedback__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__JoyFeedback__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__msg__JoyFeedback__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__JoyFeedback__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__JoyFeedback__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__JoyFeedback__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__JoyFeedback__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__JoyFeedback__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__JoyFeedbackArray {
    pub array: sensor_msgs__msg__JoyFeedback__Sequence,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__JoyFeedbackArray() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__JoyFeedbackArray> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__JoyFeedbackArray>(),
        24usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__JoyFeedbackArray))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__JoyFeedbackArray>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__JoyFeedbackArray)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).array) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__JoyFeedbackArray),
            "::",
            stringify!(array)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__JoyFeedbackArray__Sequence {
    pub data: *mut sensor_msgs__msg__JoyFeedbackArray,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__JoyFeedbackArray__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__JoyFeedbackArray__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__JoyFeedbackArray__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__msg__JoyFeedbackArray__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__JoyFeedbackArray__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__JoyFeedbackArray__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__JoyFeedbackArray__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__JoyFeedbackArray__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__JoyFeedbackArray__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct sensor_msgs__msg__LaserEcho {
    pub echoes: rosidl_runtime_c__float__Sequence,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__LaserEcho() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__LaserEcho> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__LaserEcho>(),
        24usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__LaserEcho))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__LaserEcho>(),
        8usize,
        concat!("Alignment of ", stringify!(sensor_msgs__msg__LaserEcho))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).echoes) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__LaserEcho),
            "::",
            stringify!(echoes)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__LaserEcho__Sequence {
    pub data: *mut sensor_msgs__msg__LaserEcho,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__LaserEcho__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__LaserEcho__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__LaserEcho__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__msg__LaserEcho__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__LaserEcho__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__LaserEcho__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__LaserEcho__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__LaserEcho__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__LaserEcho__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct sensor_msgs__msg__LaserScan {
    pub header: std_msgs__msg__Header,
    pub angle_min: f32,
    pub angle_max: f32,
    pub angle_increment: f32,
    pub time_increment: f32,
    pub scan_time: f32,
    pub range_min: f32,
    pub range_max: f32,
    pub ranges: rosidl_runtime_c__float__Sequence,
    pub intensities: rosidl_runtime_c__float__Sequence,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__LaserScan() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__LaserScan> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__LaserScan>(),
        112usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__LaserScan))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__LaserScan>(),
        8usize,
        concat!("Alignment of ", stringify!(sensor_msgs__msg__LaserScan))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__LaserScan),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).angle_min) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__LaserScan),
            "::",
            stringify!(angle_min)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).angle_max) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__LaserScan),
            "::",
            stringify!(angle_max)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).angle_increment) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__LaserScan),
            "::",
            stringify!(angle_increment)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).time_increment) as usize - ptr as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__LaserScan),
            "::",
            stringify!(time_increment)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scan_time) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__LaserScan),
            "::",
            stringify!(scan_time)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).range_min) as usize - ptr as usize },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__LaserScan),
            "::",
            stringify!(range_min)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).range_max) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__LaserScan),
            "::",
            stringify!(range_max)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ranges) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__LaserScan),
            "::",
            stringify!(ranges)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).intensities) as usize - ptr as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__LaserScan),
            "::",
            stringify!(intensities)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__LaserScan__Sequence {
    pub data: *mut sensor_msgs__msg__LaserScan,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__LaserScan__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__LaserScan__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__LaserScan__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__msg__LaserScan__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__LaserScan__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__LaserScan__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__LaserScan__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__LaserScan__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__LaserScan__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct sensor_msgs__msg__MagneticField {
    pub header: std_msgs__msg__Header,
    pub magnetic_field: geometry_msgs__msg__Vector3,
    pub magnetic_field_covariance: [f64; 9usize],
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__MagneticField() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__MagneticField> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__MagneticField>(),
        128usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__MagneticField))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__MagneticField>(),
        8usize,
        concat!("Alignment of ", stringify!(sensor_msgs__msg__MagneticField))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MagneticField),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).magnetic_field) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MagneticField),
            "::",
            stringify!(magnetic_field)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).magnetic_field_covariance) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MagneticField),
            "::",
            stringify!(magnetic_field_covariance)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__MagneticField__Sequence {
    pub data: *mut sensor_msgs__msg__MagneticField,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__MagneticField__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__MagneticField__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__MagneticField__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__msg__MagneticField__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__MagneticField__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__MagneticField__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MagneticField__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MagneticField__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MagneticField__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct sensor_msgs__msg__MultiDOFJointState {
    pub header: std_msgs__msg__Header,
    pub joint_names: rosidl_runtime_c__String__Sequence,
    pub transforms: geometry_msgs__msg__Transform__Sequence,
    pub twist: geometry_msgs__msg__Twist__Sequence,
    pub wrench: geometry_msgs__msg__Wrench__Sequence,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__MultiDOFJointState() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__MultiDOFJointState> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__MultiDOFJointState>(),
        128usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__msg__MultiDOFJointState)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__MultiDOFJointState>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__MultiDOFJointState)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MultiDOFJointState),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).joint_names) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MultiDOFJointState),
            "::",
            stringify!(joint_names)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).transforms) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MultiDOFJointState),
            "::",
            stringify!(transforms)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).twist) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MultiDOFJointState),
            "::",
            stringify!(twist)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wrench) as usize - ptr as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MultiDOFJointState),
            "::",
            stringify!(wrench)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__MultiDOFJointState__Sequence {
    pub data: *mut sensor_msgs__msg__MultiDOFJointState,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__MultiDOFJointState__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__MultiDOFJointState__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__MultiDOFJointState__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__msg__MultiDOFJointState__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__MultiDOFJointState__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__MultiDOFJointState__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MultiDOFJointState__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MultiDOFJointState__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MultiDOFJointState__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct sensor_msgs__msg__MultiEchoLaserScan {
    pub header: std_msgs__msg__Header,
    pub angle_min: f32,
    pub angle_max: f32,
    pub angle_increment: f32,
    pub time_increment: f32,
    pub scan_time: f32,
    pub range_min: f32,
    pub range_max: f32,
    pub ranges: sensor_msgs__msg__LaserEcho__Sequence,
    pub intensities: sensor_msgs__msg__LaserEcho__Sequence,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__MultiEchoLaserScan() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__MultiEchoLaserScan> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__MultiEchoLaserScan>(),
        112usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__msg__MultiEchoLaserScan)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__MultiEchoLaserScan>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__MultiEchoLaserScan)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MultiEchoLaserScan),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).angle_min) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MultiEchoLaserScan),
            "::",
            stringify!(angle_min)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).angle_max) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MultiEchoLaserScan),
            "::",
            stringify!(angle_max)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).angle_increment) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MultiEchoLaserScan),
            "::",
            stringify!(angle_increment)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).time_increment) as usize - ptr as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MultiEchoLaserScan),
            "::",
            stringify!(time_increment)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scan_time) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MultiEchoLaserScan),
            "::",
            stringify!(scan_time)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).range_min) as usize - ptr as usize },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MultiEchoLaserScan),
            "::",
            stringify!(range_min)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).range_max) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MultiEchoLaserScan),
            "::",
            stringify!(range_max)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ranges) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MultiEchoLaserScan),
            "::",
            stringify!(ranges)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).intensities) as usize - ptr as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MultiEchoLaserScan),
            "::",
            stringify!(intensities)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__MultiEchoLaserScan__Sequence {
    pub data: *mut sensor_msgs__msg__MultiEchoLaserScan,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__MultiEchoLaserScan__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__MultiEchoLaserScan__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__MultiEchoLaserScan__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__msg__MultiEchoLaserScan__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__MultiEchoLaserScan__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__MultiEchoLaserScan__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MultiEchoLaserScan__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MultiEchoLaserScan__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__MultiEchoLaserScan__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const sensor_msgs__msg__NavSatFix__COVARIANCE_TYPE_UNKNOWN: _bindgen_ty_104 =
    _bindgen_ty_104::sensor_msgs__msg__NavSatFix__COVARIANCE_TYPE_UNKNOWN;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_104 {
    sensor_msgs__msg__NavSatFix__COVARIANCE_TYPE_UNKNOWN = 0,
}
pub const sensor_msgs__msg__NavSatFix__COVARIANCE_TYPE_APPROXIMATED: _bindgen_ty_105 =
    _bindgen_ty_105::sensor_msgs__msg__NavSatFix__COVARIANCE_TYPE_APPROXIMATED;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_105 {
    sensor_msgs__msg__NavSatFix__COVARIANCE_TYPE_APPROXIMATED = 1,
}
pub const sensor_msgs__msg__NavSatFix__COVARIANCE_TYPE_DIAGONAL_KNOWN: _bindgen_ty_106 =
    _bindgen_ty_106::sensor_msgs__msg__NavSatFix__COVARIANCE_TYPE_DIAGONAL_KNOWN;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_106 {
    sensor_msgs__msg__NavSatFix__COVARIANCE_TYPE_DIAGONAL_KNOWN = 2,
}
pub const sensor_msgs__msg__NavSatFix__COVARIANCE_TYPE_KNOWN: _bindgen_ty_107 =
    _bindgen_ty_107::sensor_msgs__msg__NavSatFix__COVARIANCE_TYPE_KNOWN;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_107 {
    sensor_msgs__msg__NavSatFix__COVARIANCE_TYPE_KNOWN = 3,
}
pub const sensor_msgs__msg__NavSatStatus__STATUS_NO_FIX: _bindgen_ty_108 =
    _bindgen_ty_108::sensor_msgs__msg__NavSatStatus__STATUS_NO_FIX;
#[repr(i32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_108 {
    sensor_msgs__msg__NavSatStatus__STATUS_NO_FIX = -1,
}
pub const sensor_msgs__msg__NavSatStatus__STATUS_FIX: _bindgen_ty_109 =
    _bindgen_ty_109::sensor_msgs__msg__NavSatStatus__STATUS_FIX;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_109 {
    sensor_msgs__msg__NavSatStatus__STATUS_FIX = 0,
}
pub const sensor_msgs__msg__NavSatStatus__STATUS_SBAS_FIX: _bindgen_ty_110 =
    _bindgen_ty_110::sensor_msgs__msg__NavSatStatus__STATUS_SBAS_FIX;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_110 {
    sensor_msgs__msg__NavSatStatus__STATUS_SBAS_FIX = 1,
}
pub const sensor_msgs__msg__NavSatStatus__STATUS_GBAS_FIX: _bindgen_ty_111 =
    _bindgen_ty_111::sensor_msgs__msg__NavSatStatus__STATUS_GBAS_FIX;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_111 {
    sensor_msgs__msg__NavSatStatus__STATUS_GBAS_FIX = 2,
}
pub const sensor_msgs__msg__NavSatStatus__SERVICE_GPS: _bindgen_ty_112 =
    _bindgen_ty_112::sensor_msgs__msg__NavSatStatus__SERVICE_GPS;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_112 {
    sensor_msgs__msg__NavSatStatus__SERVICE_GPS = 1,
}
pub const sensor_msgs__msg__NavSatStatus__SERVICE_GLONASS: _bindgen_ty_113 =
    _bindgen_ty_113::sensor_msgs__msg__NavSatStatus__SERVICE_GLONASS;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_113 {
    sensor_msgs__msg__NavSatStatus__SERVICE_GLONASS = 2,
}
pub const sensor_msgs__msg__NavSatStatus__SERVICE_COMPASS: _bindgen_ty_114 =
    _bindgen_ty_114::sensor_msgs__msg__NavSatStatus__SERVICE_COMPASS;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_114 {
    sensor_msgs__msg__NavSatStatus__SERVICE_COMPASS = 4,
}
pub const sensor_msgs__msg__NavSatStatus__SERVICE_GALILEO: _bindgen_ty_115 =
    _bindgen_ty_115::sensor_msgs__msg__NavSatStatus__SERVICE_GALILEO;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_115 {
    sensor_msgs__msg__NavSatStatus__SERVICE_GALILEO = 8,
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__NavSatStatus {
    pub status: i8,
    pub service: u16,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__NavSatStatus() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__NavSatStatus> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__NavSatStatus>(),
        4usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__NavSatStatus))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__NavSatStatus>(),
        2usize,
        concat!("Alignment of ", stringify!(sensor_msgs__msg__NavSatStatus))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).status) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__NavSatStatus),
            "::",
            stringify!(status)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).service) as usize - ptr as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__NavSatStatus),
            "::",
            stringify!(service)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__NavSatStatus__Sequence {
    pub data: *mut sensor_msgs__msg__NavSatStatus,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__NavSatStatus__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__NavSatStatus__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__NavSatStatus__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__msg__NavSatStatus__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__NavSatStatus__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__NavSatStatus__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__NavSatStatus__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__NavSatStatus__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__NavSatStatus__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct sensor_msgs__msg__NavSatFix {
    pub header: std_msgs__msg__Header,
    pub status: sensor_msgs__msg__NavSatStatus,
    pub latitude: f64,
    pub longitude: f64,
    pub altitude: f64,
    pub position_covariance: [f64; 9usize],
    pub position_covariance_type: u8,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__NavSatFix() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__NavSatFix> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__NavSatFix>(),
        144usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__NavSatFix))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__NavSatFix>(),
        8usize,
        concat!("Alignment of ", stringify!(sensor_msgs__msg__NavSatFix))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__NavSatFix),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).status) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__NavSatFix),
            "::",
            stringify!(status)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).latitude) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__NavSatFix),
            "::",
            stringify!(latitude)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).longitude) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__NavSatFix),
            "::",
            stringify!(longitude)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).altitude) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__NavSatFix),
            "::",
            stringify!(altitude)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).position_covariance) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__NavSatFix),
            "::",
            stringify!(position_covariance)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).position_covariance_type) as usize - ptr as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__NavSatFix),
            "::",
            stringify!(position_covariance_type)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__NavSatFix__Sequence {
    pub data: *mut sensor_msgs__msg__NavSatFix,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__NavSatFix__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__NavSatFix__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__NavSatFix__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__msg__NavSatFix__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__NavSatFix__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__NavSatFix__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__NavSatFix__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__NavSatFix__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__NavSatFix__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct sensor_msgs__msg__PointCloud {
    pub header: std_msgs__msg__Header,
    pub points: geometry_msgs__msg__Point32__Sequence,
    pub channels: sensor_msgs__msg__ChannelFloat32__Sequence,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__PointCloud() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__PointCloud> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__PointCloud>(),
        80usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__PointCloud))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__PointCloud>(),
        8usize,
        concat!("Alignment of ", stringify!(sensor_msgs__msg__PointCloud))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__PointCloud),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).points) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__PointCloud),
            "::",
            stringify!(points)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).channels) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__PointCloud),
            "::",
            stringify!(channels)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__PointCloud__Sequence {
    pub data: *mut sensor_msgs__msg__PointCloud,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__PointCloud__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__PointCloud__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__PointCloud__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__msg__PointCloud__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__PointCloud__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__PointCloud__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__PointCloud__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__PointCloud__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__PointCloud__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const sensor_msgs__msg__PointField__INT8: _bindgen_ty_116 =
    _bindgen_ty_116::sensor_msgs__msg__PointField__INT8;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_116 {
    sensor_msgs__msg__PointField__INT8 = 1,
}
pub const sensor_msgs__msg__PointField__UINT8: _bindgen_ty_117 =
    _bindgen_ty_117::sensor_msgs__msg__PointField__UINT8;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_117 {
    sensor_msgs__msg__PointField__UINT8 = 2,
}
pub const sensor_msgs__msg__PointField__INT16: _bindgen_ty_118 =
    _bindgen_ty_118::sensor_msgs__msg__PointField__INT16;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_118 {
    sensor_msgs__msg__PointField__INT16 = 3,
}
pub const sensor_msgs__msg__PointField__UINT16: _bindgen_ty_119 =
    _bindgen_ty_119::sensor_msgs__msg__PointField__UINT16;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_119 {
    sensor_msgs__msg__PointField__UINT16 = 4,
}
pub const sensor_msgs__msg__PointField__INT32: _bindgen_ty_120 =
    _bindgen_ty_120::sensor_msgs__msg__PointField__INT32;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_120 {
    sensor_msgs__msg__PointField__INT32 = 5,
}
pub const sensor_msgs__msg__PointField__UINT32: _bindgen_ty_121 =
    _bindgen_ty_121::sensor_msgs__msg__PointField__UINT32;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_121 {
    sensor_msgs__msg__PointField__UINT32 = 6,
}
pub const sensor_msgs__msg__PointField__FLOAT32: _bindgen_ty_122 =
    _bindgen_ty_122::sensor_msgs__msg__PointField__FLOAT32;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_122 {
    sensor_msgs__msg__PointField__FLOAT32 = 7,
}
pub const sensor_msgs__msg__PointField__FLOAT64: _bindgen_ty_123 =
    _bindgen_ty_123::sensor_msgs__msg__PointField__FLOAT64;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_123 {
    sensor_msgs__msg__PointField__FLOAT64 = 8,
}
#[repr(C)]
pub struct sensor_msgs__msg__PointField {
    pub name: rosidl_runtime_c__String,
    pub offset: u32,
    pub datatype: u8,
    pub count: u32,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__PointField() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__PointField> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__PointField>(),
        40usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__PointField))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__PointField>(),
        8usize,
        concat!("Alignment of ", stringify!(sensor_msgs__msg__PointField))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__PointField),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__PointField),
            "::",
            stringify!(offset)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).datatype) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__PointField),
            "::",
            stringify!(datatype)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).count) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__PointField),
            "::",
            stringify!(count)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__PointField__Sequence {
    pub data: *mut sensor_msgs__msg__PointField,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__PointField__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__PointField__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__PointField__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__msg__PointField__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__PointField__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__PointField__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__PointField__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__PointField__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__PointField__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct sensor_msgs__msg__PointCloud2 {
    pub header: std_msgs__msg__Header,
    pub height: u32,
    pub width: u32,
    pub fields: sensor_msgs__msg__PointField__Sequence,
    pub is_bigendian: bool,
    pub point_step: u32,
    pub row_step: u32,
    pub data: rosidl_runtime_c__uint8__Sequence,
    pub is_dense: bool,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__PointCloud2() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__PointCloud2> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__PointCloud2>(),
        112usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__PointCloud2))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__PointCloud2>(),
        8usize,
        concat!("Alignment of ", stringify!(sensor_msgs__msg__PointCloud2))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__PointCloud2),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__PointCloud2),
            "::",
            stringify!(height)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__PointCloud2),
            "::",
            stringify!(width)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fields) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__PointCloud2),
            "::",
            stringify!(fields)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).is_bigendian) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__PointCloud2),
            "::",
            stringify!(is_bigendian)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).point_step) as usize - ptr as usize },
        68usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__PointCloud2),
            "::",
            stringify!(point_step)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).row_step) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__PointCloud2),
            "::",
            stringify!(row_step)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__PointCloud2),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).is_dense) as usize - ptr as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__PointCloud2),
            "::",
            stringify!(is_dense)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__PointCloud2__Sequence {
    pub data: *mut sensor_msgs__msg__PointCloud2,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__PointCloud2__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__PointCloud2__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__PointCloud2__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__msg__PointCloud2__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__PointCloud2__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__PointCloud2__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__PointCloud2__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__PointCloud2__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__PointCloud2__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const sensor_msgs__msg__Range__ULTRASOUND: _bindgen_ty_124 =
    _bindgen_ty_124::sensor_msgs__msg__Range__ULTRASOUND;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_124 {
    sensor_msgs__msg__Range__ULTRASOUND = 0,
}
pub const sensor_msgs__msg__Range__INFRARED: _bindgen_ty_125 =
    _bindgen_ty_125::sensor_msgs__msg__Range__INFRARED;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_125 {
    sensor_msgs__msg__Range__INFRARED = 1,
}
#[repr(C)]
pub struct sensor_msgs__msg__Range {
    pub header: std_msgs__msg__Header,
    pub radiation_type: u8,
    pub field_of_view: f32,
    pub min_range: f32,
    pub max_range: f32,
    pub range: f32,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__Range() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__Range> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__Range>(),
        56usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__Range))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__Range>(),
        8usize,
        concat!("Alignment of ", stringify!(sensor_msgs__msg__Range))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Range),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).radiation_type) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Range),
            "::",
            stringify!(radiation_type)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).field_of_view) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Range),
            "::",
            stringify!(field_of_view)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).min_range) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Range),
            "::",
            stringify!(min_range)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_range) as usize - ptr as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Range),
            "::",
            stringify!(max_range)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).range) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Range),
            "::",
            stringify!(range)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__Range__Sequence {
    pub data: *mut sensor_msgs__msg__Range,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__Range__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__Range__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__Range__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__Range__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__Range__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__Range__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Range__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Range__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Range__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct sensor_msgs__msg__RelativeHumidity {
    pub header: std_msgs__msg__Header,
    pub relative_humidity: f64,
    pub variance: f64,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__RelativeHumidity() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__RelativeHumidity> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__RelativeHumidity>(),
        48usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__RelativeHumidity))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__RelativeHumidity>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__RelativeHumidity)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__RelativeHumidity),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).relative_humidity) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__RelativeHumidity),
            "::",
            stringify!(relative_humidity)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).variance) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__RelativeHumidity),
            "::",
            stringify!(variance)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__RelativeHumidity__Sequence {
    pub data: *mut sensor_msgs__msg__RelativeHumidity,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__RelativeHumidity__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__RelativeHumidity__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__RelativeHumidity__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__msg__RelativeHumidity__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__RelativeHumidity__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__RelativeHumidity__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__RelativeHumidity__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__RelativeHumidity__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__RelativeHumidity__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct sensor_msgs__msg__Temperature {
    pub header: std_msgs__msg__Header,
    pub temperature: f64,
    pub variance: f64,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__Temperature() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__Temperature> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__Temperature>(),
        48usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__Temperature))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__Temperature>(),
        8usize,
        concat!("Alignment of ", stringify!(sensor_msgs__msg__Temperature))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Temperature),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).temperature) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Temperature),
            "::",
            stringify!(temperature)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).variance) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Temperature),
            "::",
            stringify!(variance)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__Temperature__Sequence {
    pub data: *mut sensor_msgs__msg__Temperature,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__Temperature__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__Temperature__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__Temperature__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__msg__Temperature__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__Temperature__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__Temperature__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Temperature__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Temperature__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__Temperature__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct sensor_msgs__msg__TimeReference {
    pub header: std_msgs__msg__Header,
    pub time_ref: builtin_interfaces__msg__Time,
    pub source: rosidl_runtime_c__String,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__TimeReference() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__TimeReference> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__TimeReference>(),
        64usize,
        concat!("Size of: ", stringify!(sensor_msgs__msg__TimeReference))
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__TimeReference>(),
        8usize,
        concat!("Alignment of ", stringify!(sensor_msgs__msg__TimeReference))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__TimeReference),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).time_ref) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__TimeReference),
            "::",
            stringify!(time_ref)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).source) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__TimeReference),
            "::",
            stringify!(source)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__msg__TimeReference__Sequence {
    pub data: *mut sensor_msgs__msg__TimeReference,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__msg__TimeReference__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__msg__TimeReference__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__msg__TimeReference__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__msg__TimeReference__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__msg__TimeReference__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__msg__TimeReference__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__TimeReference__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__TimeReference__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__msg__TimeReference__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct sensor_msgs__srv__SetCameraInfo_Request {
    pub camera_info: sensor_msgs__msg__CameraInfo,
}
#[test]
fn bindgen_test_layout_sensor_msgs__srv__SetCameraInfo_Request() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__srv__SetCameraInfo_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__srv__SetCameraInfo_Request>(),
        360usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__srv__SetCameraInfo_Request)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__srv__SetCameraInfo_Request>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__srv__SetCameraInfo_Request)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).camera_info) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__srv__SetCameraInfo_Request),
            "::",
            stringify!(camera_info)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__srv__SetCameraInfo_Request__Sequence {
    pub data: *mut sensor_msgs__srv__SetCameraInfo_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__srv__SetCameraInfo_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__srv__SetCameraInfo_Request__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__srv__SetCameraInfo_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__srv__SetCameraInfo_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__srv__SetCameraInfo_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__srv__SetCameraInfo_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__srv__SetCameraInfo_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__srv__SetCameraInfo_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__srv__SetCameraInfo_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct sensor_msgs__srv__SetCameraInfo_Response {
    pub success: bool,
    pub status_message: rosidl_runtime_c__String,
}
#[test]
fn bindgen_test_layout_sensor_msgs__srv__SetCameraInfo_Response() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__srv__SetCameraInfo_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__srv__SetCameraInfo_Response>(),
        32usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__srv__SetCameraInfo_Response)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__srv__SetCameraInfo_Response>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__srv__SetCameraInfo_Response)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).success) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__srv__SetCameraInfo_Response),
            "::",
            stringify!(success)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).status_message) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__srv__SetCameraInfo_Response),
            "::",
            stringify!(status_message)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct sensor_msgs__srv__SetCameraInfo_Response__Sequence {
    pub data: *mut sensor_msgs__srv__SetCameraInfo_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_sensor_msgs__srv__SetCameraInfo_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<sensor_msgs__srv__SetCameraInfo_Response__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<sensor_msgs__srv__SetCameraInfo_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(sensor_msgs__srv__SetCameraInfo_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<sensor_msgs__srv__SetCameraInfo_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(sensor_msgs__srv__SetCameraInfo_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__srv__SetCameraInfo_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__srv__SetCameraInfo_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(sensor_msgs__srv__SetCameraInfo_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct shape_msgs__msg__MeshTriangle {
    pub vertex_indices: [u32; 3usize],
}
#[test]
fn bindgen_test_layout_shape_msgs__msg__MeshTriangle() {
    const UNINIT: ::std::mem::MaybeUninit<shape_msgs__msg__MeshTriangle> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<shape_msgs__msg__MeshTriangle>(),
        12usize,
        concat!("Size of: ", stringify!(shape_msgs__msg__MeshTriangle))
    );
    assert_eq!(
        ::std::mem::align_of::<shape_msgs__msg__MeshTriangle>(),
        4usize,
        concat!("Alignment of ", stringify!(shape_msgs__msg__MeshTriangle))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).vertex_indices) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(shape_msgs__msg__MeshTriangle),
            "::",
            stringify!(vertex_indices)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct shape_msgs__msg__MeshTriangle__Sequence {
    pub data: *mut shape_msgs__msg__MeshTriangle,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_shape_msgs__msg__MeshTriangle__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<shape_msgs__msg__MeshTriangle__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<shape_msgs__msg__MeshTriangle__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(shape_msgs__msg__MeshTriangle__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<shape_msgs__msg__MeshTriangle__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(shape_msgs__msg__MeshTriangle__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(shape_msgs__msg__MeshTriangle__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(shape_msgs__msg__MeshTriangle__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(shape_msgs__msg__MeshTriangle__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct shape_msgs__msg__Mesh {
    pub triangles: shape_msgs__msg__MeshTriangle__Sequence,
    pub vertices: geometry_msgs__msg__Point__Sequence,
}
#[test]
fn bindgen_test_layout_shape_msgs__msg__Mesh() {
    const UNINIT: ::std::mem::MaybeUninit<shape_msgs__msg__Mesh> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<shape_msgs__msg__Mesh>(),
        48usize,
        concat!("Size of: ", stringify!(shape_msgs__msg__Mesh))
    );
    assert_eq!(
        ::std::mem::align_of::<shape_msgs__msg__Mesh>(),
        8usize,
        concat!("Alignment of ", stringify!(shape_msgs__msg__Mesh))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).triangles) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(shape_msgs__msg__Mesh),
            "::",
            stringify!(triangles)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).vertices) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(shape_msgs__msg__Mesh),
            "::",
            stringify!(vertices)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct shape_msgs__msg__Mesh__Sequence {
    pub data: *mut shape_msgs__msg__Mesh,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_shape_msgs__msg__Mesh__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<shape_msgs__msg__Mesh__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<shape_msgs__msg__Mesh__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(shape_msgs__msg__Mesh__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<shape_msgs__msg__Mesh__Sequence>(),
        8usize,
        concat!("Alignment of ", stringify!(shape_msgs__msg__Mesh__Sequence))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(shape_msgs__msg__Mesh__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(shape_msgs__msg__Mesh__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(shape_msgs__msg__Mesh__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct shape_msgs__msg__Plane {
    pub coef: [f64; 4usize],
}
#[test]
fn bindgen_test_layout_shape_msgs__msg__Plane() {
    const UNINIT: ::std::mem::MaybeUninit<shape_msgs__msg__Plane> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<shape_msgs__msg__Plane>(),
        32usize,
        concat!("Size of: ", stringify!(shape_msgs__msg__Plane))
    );
    assert_eq!(
        ::std::mem::align_of::<shape_msgs__msg__Plane>(),
        8usize,
        concat!("Alignment of ", stringify!(shape_msgs__msg__Plane))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).coef) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(shape_msgs__msg__Plane),
            "::",
            stringify!(coef)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct shape_msgs__msg__Plane__Sequence {
    pub data: *mut shape_msgs__msg__Plane,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_shape_msgs__msg__Plane__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<shape_msgs__msg__Plane__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<shape_msgs__msg__Plane__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(shape_msgs__msg__Plane__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<shape_msgs__msg__Plane__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(shape_msgs__msg__Plane__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(shape_msgs__msg__Plane__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(shape_msgs__msg__Plane__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(shape_msgs__msg__Plane__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const shape_msgs__msg__SolidPrimitive__BOX: _bindgen_ty_126 =
    _bindgen_ty_126::shape_msgs__msg__SolidPrimitive__BOX;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_126 {
    shape_msgs__msg__SolidPrimitive__BOX = 1,
}
pub const shape_msgs__msg__SolidPrimitive__SPHERE: _bindgen_ty_127 =
    _bindgen_ty_127::shape_msgs__msg__SolidPrimitive__SPHERE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_127 {
    shape_msgs__msg__SolidPrimitive__SPHERE = 2,
}
pub const shape_msgs__msg__SolidPrimitive__CYLINDER: _bindgen_ty_128 =
    _bindgen_ty_128::shape_msgs__msg__SolidPrimitive__CYLINDER;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_128 {
    shape_msgs__msg__SolidPrimitive__CYLINDER = 3,
}
pub const shape_msgs__msg__SolidPrimitive__CONE: _bindgen_ty_129 =
    _bindgen_ty_129::shape_msgs__msg__SolidPrimitive__CONE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_129 {
    shape_msgs__msg__SolidPrimitive__CONE = 4,
}
pub const shape_msgs__msg__SolidPrimitive__PRISM: _bindgen_ty_130 =
    _bindgen_ty_130::shape_msgs__msg__SolidPrimitive__PRISM;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_130 {
    shape_msgs__msg__SolidPrimitive__PRISM = 5,
}
pub const shape_msgs__msg__SolidPrimitive__BOX_X: _bindgen_ty_131 =
    _bindgen_ty_131::shape_msgs__msg__SolidPrimitive__BOX_X;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_131 {
    shape_msgs__msg__SolidPrimitive__BOX_X = 0,
}
pub const shape_msgs__msg__SolidPrimitive__BOX_Y: _bindgen_ty_132 =
    _bindgen_ty_132::shape_msgs__msg__SolidPrimitive__BOX_Y;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_132 {
    shape_msgs__msg__SolidPrimitive__BOX_Y = 1,
}
pub const shape_msgs__msg__SolidPrimitive__BOX_Z: _bindgen_ty_133 =
    _bindgen_ty_133::shape_msgs__msg__SolidPrimitive__BOX_Z;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_133 {
    shape_msgs__msg__SolidPrimitive__BOX_Z = 2,
}
pub const shape_msgs__msg__SolidPrimitive__SPHERE_RADIUS: _bindgen_ty_134 =
    _bindgen_ty_134::shape_msgs__msg__SolidPrimitive__SPHERE_RADIUS;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_134 {
    shape_msgs__msg__SolidPrimitive__SPHERE_RADIUS = 0,
}
pub const shape_msgs__msg__SolidPrimitive__CYLINDER_HEIGHT: _bindgen_ty_135 =
    _bindgen_ty_135::shape_msgs__msg__SolidPrimitive__CYLINDER_HEIGHT;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_135 {
    shape_msgs__msg__SolidPrimitive__CYLINDER_HEIGHT = 0,
}
pub const shape_msgs__msg__SolidPrimitive__CYLINDER_RADIUS: _bindgen_ty_136 =
    _bindgen_ty_136::shape_msgs__msg__SolidPrimitive__CYLINDER_RADIUS;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_136 {
    shape_msgs__msg__SolidPrimitive__CYLINDER_RADIUS = 1,
}
pub const shape_msgs__msg__SolidPrimitive__CONE_HEIGHT: _bindgen_ty_137 =
    _bindgen_ty_137::shape_msgs__msg__SolidPrimitive__CONE_HEIGHT;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_137 {
    shape_msgs__msg__SolidPrimitive__CONE_HEIGHT = 0,
}
pub const shape_msgs__msg__SolidPrimitive__CONE_RADIUS: _bindgen_ty_138 =
    _bindgen_ty_138::shape_msgs__msg__SolidPrimitive__CONE_RADIUS;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_138 {
    shape_msgs__msg__SolidPrimitive__CONE_RADIUS = 1,
}
pub const shape_msgs__msg__SolidPrimitive__PRISM_HEIGHT: _bindgen_ty_139 =
    _bindgen_ty_139::shape_msgs__msg__SolidPrimitive__PRISM_HEIGHT;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_139 {
    shape_msgs__msg__SolidPrimitive__PRISM_HEIGHT = 0,
}
pub const shape_msgs__msg__SolidPrimitive__dimensions__MAX_SIZE: _bindgen_ty_140 =
    _bindgen_ty_140::shape_msgs__msg__SolidPrimitive__dimensions__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_140 {
    shape_msgs__msg__SolidPrimitive__dimensions__MAX_SIZE = 3,
}
#[repr(C)]
pub struct shape_msgs__msg__SolidPrimitive {
    pub type_: u8,
    pub dimensions: rosidl_runtime_c__double__Sequence,
    pub polygon: geometry_msgs__msg__Polygon,
}
#[test]
fn bindgen_test_layout_shape_msgs__msg__SolidPrimitive() {
    const UNINIT: ::std::mem::MaybeUninit<shape_msgs__msg__SolidPrimitive> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<shape_msgs__msg__SolidPrimitive>(),
        56usize,
        concat!("Size of: ", stringify!(shape_msgs__msg__SolidPrimitive))
    );
    assert_eq!(
        ::std::mem::align_of::<shape_msgs__msg__SolidPrimitive>(),
        8usize,
        concat!("Alignment of ", stringify!(shape_msgs__msg__SolidPrimitive))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(shape_msgs__msg__SolidPrimitive),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dimensions) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(shape_msgs__msg__SolidPrimitive),
            "::",
            stringify!(dimensions)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).polygon) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(shape_msgs__msg__SolidPrimitive),
            "::",
            stringify!(polygon)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct shape_msgs__msg__SolidPrimitive__Sequence {
    pub data: *mut shape_msgs__msg__SolidPrimitive,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_shape_msgs__msg__SolidPrimitive__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<shape_msgs__msg__SolidPrimitive__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<shape_msgs__msg__SolidPrimitive__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(shape_msgs__msg__SolidPrimitive__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<shape_msgs__msg__SolidPrimitive__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(shape_msgs__msg__SolidPrimitive__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(shape_msgs__msg__SolidPrimitive__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(shape_msgs__msg__SolidPrimitive__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(shape_msgs__msg__SolidPrimitive__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct statistics_msgs__msg__StatisticDataPoint {
    pub data_type: u8,
    pub data: f64,
}
#[test]
fn bindgen_test_layout_statistics_msgs__msg__StatisticDataPoint() {
    const UNINIT: ::std::mem::MaybeUninit<statistics_msgs__msg__StatisticDataPoint> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<statistics_msgs__msg__StatisticDataPoint>(),
        16usize,
        concat!(
            "Size of: ",
            stringify!(statistics_msgs__msg__StatisticDataPoint)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<statistics_msgs__msg__StatisticDataPoint>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(statistics_msgs__msg__StatisticDataPoint)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data_type) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(statistics_msgs__msg__StatisticDataPoint),
            "::",
            stringify!(data_type)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(statistics_msgs__msg__StatisticDataPoint),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct statistics_msgs__msg__StatisticDataPoint__Sequence {
    pub data: *mut statistics_msgs__msg__StatisticDataPoint,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_statistics_msgs__msg__StatisticDataPoint__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<statistics_msgs__msg__StatisticDataPoint__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<statistics_msgs__msg__StatisticDataPoint__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(statistics_msgs__msg__StatisticDataPoint__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<statistics_msgs__msg__StatisticDataPoint__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(statistics_msgs__msg__StatisticDataPoint__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(statistics_msgs__msg__StatisticDataPoint__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(statistics_msgs__msg__StatisticDataPoint__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(statistics_msgs__msg__StatisticDataPoint__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct statistics_msgs__msg__MetricsMessage {
    pub measurement_source_name: rosidl_runtime_c__String,
    pub metrics_source: rosidl_runtime_c__String,
    pub unit: rosidl_runtime_c__String,
    pub window_start: builtin_interfaces__msg__Time,
    pub window_stop: builtin_interfaces__msg__Time,
    pub statistics: statistics_msgs__msg__StatisticDataPoint__Sequence,
}
#[test]
fn bindgen_test_layout_statistics_msgs__msg__MetricsMessage() {
    const UNINIT: ::std::mem::MaybeUninit<statistics_msgs__msg__MetricsMessage> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<statistics_msgs__msg__MetricsMessage>(),
        112usize,
        concat!(
            "Size of: ",
            stringify!(statistics_msgs__msg__MetricsMessage)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<statistics_msgs__msg__MetricsMessage>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(statistics_msgs__msg__MetricsMessage)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).measurement_source_name) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(statistics_msgs__msg__MetricsMessage),
            "::",
            stringify!(measurement_source_name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).metrics_source) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(statistics_msgs__msg__MetricsMessage),
            "::",
            stringify!(metrics_source)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).unit) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(statistics_msgs__msg__MetricsMessage),
            "::",
            stringify!(unit)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).window_start) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(statistics_msgs__msg__MetricsMessage),
            "::",
            stringify!(window_start)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).window_stop) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(statistics_msgs__msg__MetricsMessage),
            "::",
            stringify!(window_stop)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).statistics) as usize - ptr as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(statistics_msgs__msg__MetricsMessage),
            "::",
            stringify!(statistics)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct statistics_msgs__msg__MetricsMessage__Sequence {
    pub data: *mut statistics_msgs__msg__MetricsMessage,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_statistics_msgs__msg__MetricsMessage__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<statistics_msgs__msg__MetricsMessage__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<statistics_msgs__msg__MetricsMessage__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(statistics_msgs__msg__MetricsMessage__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<statistics_msgs__msg__MetricsMessage__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(statistics_msgs__msg__MetricsMessage__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(statistics_msgs__msg__MetricsMessage__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(statistics_msgs__msg__MetricsMessage__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(statistics_msgs__msg__MetricsMessage__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const statistics_msgs__msg__StatisticDataType__STATISTICS_DATA_TYPE_UNINITIALIZED:
    _bindgen_ty_141 =
    _bindgen_ty_141::statistics_msgs__msg__StatisticDataType__STATISTICS_DATA_TYPE_UNINITIALIZED;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_141 {
    statistics_msgs__msg__StatisticDataType__STATISTICS_DATA_TYPE_UNINITIALIZED = 0,
}
pub const statistics_msgs__msg__StatisticDataType__STATISTICS_DATA_TYPE_AVERAGE: _bindgen_ty_142 =
    _bindgen_ty_142::statistics_msgs__msg__StatisticDataType__STATISTICS_DATA_TYPE_AVERAGE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_142 {
    statistics_msgs__msg__StatisticDataType__STATISTICS_DATA_TYPE_AVERAGE = 1,
}
pub const statistics_msgs__msg__StatisticDataType__STATISTICS_DATA_TYPE_MINIMUM: _bindgen_ty_143 =
    _bindgen_ty_143::statistics_msgs__msg__StatisticDataType__STATISTICS_DATA_TYPE_MINIMUM;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_143 {
    statistics_msgs__msg__StatisticDataType__STATISTICS_DATA_TYPE_MINIMUM = 2,
}
pub const statistics_msgs__msg__StatisticDataType__STATISTICS_DATA_TYPE_MAXIMUM: _bindgen_ty_144 =
    _bindgen_ty_144::statistics_msgs__msg__StatisticDataType__STATISTICS_DATA_TYPE_MAXIMUM;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_144 {
    statistics_msgs__msg__StatisticDataType__STATISTICS_DATA_TYPE_MAXIMUM = 3,
}
pub const statistics_msgs__msg__StatisticDataType__STATISTICS_DATA_TYPE_STDDEV: _bindgen_ty_145 =
    _bindgen_ty_145::statistics_msgs__msg__StatisticDataType__STATISTICS_DATA_TYPE_STDDEV;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_145 {
    statistics_msgs__msg__StatisticDataType__STATISTICS_DATA_TYPE_STDDEV = 4,
}
pub const statistics_msgs__msg__StatisticDataType__STATISTICS_DATA_TYPE_SAMPLE_COUNT:
    _bindgen_ty_146 =
    _bindgen_ty_146::statistics_msgs__msg__StatisticDataType__STATISTICS_DATA_TYPE_SAMPLE_COUNT;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_146 {
    statistics_msgs__msg__StatisticDataType__STATISTICS_DATA_TYPE_SAMPLE_COUNT = 5,
}
#[repr(C)]
#[derive(Debug)]
pub struct statistics_msgs__msg__StatisticDataType {
    pub structure_needs_at_least_one_member: u8,
}
#[test]
fn bindgen_test_layout_statistics_msgs__msg__StatisticDataType() {
    const UNINIT: ::std::mem::MaybeUninit<statistics_msgs__msg__StatisticDataType> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<statistics_msgs__msg__StatisticDataType>(),
        1usize,
        concat!(
            "Size of: ",
            stringify!(statistics_msgs__msg__StatisticDataType)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<statistics_msgs__msg__StatisticDataType>(),
        1usize,
        concat!(
            "Alignment of ",
            stringify!(statistics_msgs__msg__StatisticDataType)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).structure_needs_at_least_one_member) as usize - ptr as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(statistics_msgs__msg__StatisticDataType),
            "::",
            stringify!(structure_needs_at_least_one_member)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct statistics_msgs__msg__StatisticDataType__Sequence {
    pub data: *mut statistics_msgs__msg__StatisticDataType,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_statistics_msgs__msg__StatisticDataType__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<statistics_msgs__msg__StatisticDataType__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<statistics_msgs__msg__StatisticDataType__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(statistics_msgs__msg__StatisticDataType__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<statistics_msgs__msg__StatisticDataType__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(statistics_msgs__msg__StatisticDataType__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(statistics_msgs__msg__StatisticDataType__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(statistics_msgs__msg__StatisticDataType__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(statistics_msgs__msg__StatisticDataType__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Bool {
    pub data: bool,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Bool() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Bool> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Bool>(),
        1usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Bool))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Bool>(),
        1usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__Bool))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Bool),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Bool__Sequence {
    pub data: *mut std_msgs__msg__Bool,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Bool__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Bool__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Bool__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Bool__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Bool__Sequence>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__Bool__Sequence))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Bool__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Bool__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Bool__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Byte {
    pub data: u8,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Byte() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Byte> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Byte>(),
        1usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Byte))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Byte>(),
        1usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__Byte))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Byte),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Byte__Sequence {
    pub data: *mut std_msgs__msg__Byte,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Byte__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Byte__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Byte__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Byte__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Byte__Sequence>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__Byte__Sequence))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Byte__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Byte__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Byte__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct std_msgs__msg__MultiArrayDimension {
    pub label: rosidl_runtime_c__String,
    pub size: u32,
    pub stride: u32,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__MultiArrayDimension() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__MultiArrayDimension> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__MultiArrayDimension>(),
        32usize,
        concat!("Size of: ", stringify!(std_msgs__msg__MultiArrayDimension))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__MultiArrayDimension>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(std_msgs__msg__MultiArrayDimension)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).label) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__MultiArrayDimension),
            "::",
            stringify!(label)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__MultiArrayDimension),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).stride) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__MultiArrayDimension),
            "::",
            stringify!(stride)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__MultiArrayDimension__Sequence {
    pub data: *mut std_msgs__msg__MultiArrayDimension,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__MultiArrayDimension__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__MultiArrayDimension__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__MultiArrayDimension__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(std_msgs__msg__MultiArrayDimension__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__MultiArrayDimension__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(std_msgs__msg__MultiArrayDimension__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__MultiArrayDimension__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__MultiArrayDimension__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__MultiArrayDimension__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__MultiArrayLayout {
    pub dim: std_msgs__msg__MultiArrayDimension__Sequence,
    pub data_offset: u32,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__MultiArrayLayout() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__MultiArrayLayout> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__MultiArrayLayout>(),
        32usize,
        concat!("Size of: ", stringify!(std_msgs__msg__MultiArrayLayout))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__MultiArrayLayout>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__MultiArrayLayout))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dim) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__MultiArrayLayout),
            "::",
            stringify!(dim)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data_offset) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__MultiArrayLayout),
            "::",
            stringify!(data_offset)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__MultiArrayLayout__Sequence {
    pub data: *mut std_msgs__msg__MultiArrayLayout,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__MultiArrayLayout__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__MultiArrayLayout__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__MultiArrayLayout__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(std_msgs__msg__MultiArrayLayout__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__MultiArrayLayout__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(std_msgs__msg__MultiArrayLayout__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__MultiArrayLayout__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__MultiArrayLayout__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__MultiArrayLayout__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct std_msgs__msg__ByteMultiArray {
    pub layout: std_msgs__msg__MultiArrayLayout,
    pub data: rosidl_runtime_c__octet__Sequence,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__ByteMultiArray() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__ByteMultiArray> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__ByteMultiArray>(),
        56usize,
        concat!("Size of: ", stringify!(std_msgs__msg__ByteMultiArray))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__ByteMultiArray>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__ByteMultiArray))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).layout) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__ByteMultiArray),
            "::",
            stringify!(layout)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__ByteMultiArray),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__ByteMultiArray__Sequence {
    pub data: *mut std_msgs__msg__ByteMultiArray,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__ByteMultiArray__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__ByteMultiArray__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__ByteMultiArray__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(std_msgs__msg__ByteMultiArray__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__ByteMultiArray__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(std_msgs__msg__ByteMultiArray__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__ByteMultiArray__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__ByteMultiArray__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__ByteMultiArray__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Char {
    pub data: u8,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Char() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Char> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Char>(),
        1usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Char))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Char>(),
        1usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__Char))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Char),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Char__Sequence {
    pub data: *mut std_msgs__msg__Char,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Char__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Char__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Char__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Char__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Char__Sequence>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__Char__Sequence))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Char__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Char__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Char__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__ColorRGBA {
    pub r: f32,
    pub g: f32,
    pub b: f32,
    pub a: f32,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__ColorRGBA() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__ColorRGBA> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__ColorRGBA>(),
        16usize,
        concat!("Size of: ", stringify!(std_msgs__msg__ColorRGBA))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__ColorRGBA>(),
        4usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__ColorRGBA))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__ColorRGBA),
            "::",
            stringify!(r)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).g) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__ColorRGBA),
            "::",
            stringify!(g)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__ColorRGBA),
            "::",
            stringify!(b)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__ColorRGBA),
            "::",
            stringify!(a)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__ColorRGBA__Sequence {
    pub data: *mut std_msgs__msg__ColorRGBA,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__ColorRGBA__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__ColorRGBA__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__ColorRGBA__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(std_msgs__msg__ColorRGBA__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__ColorRGBA__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(std_msgs__msg__ColorRGBA__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__ColorRGBA__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__ColorRGBA__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__ColorRGBA__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Empty {
    pub structure_needs_at_least_one_member: u8,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Empty() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Empty> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Empty>(),
        1usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Empty))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Empty>(),
        1usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__Empty))
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).structure_needs_at_least_one_member) as usize - ptr as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Empty),
            "::",
            stringify!(structure_needs_at_least_one_member)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Empty__Sequence {
    pub data: *mut std_msgs__msg__Empty,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Empty__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Empty__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Empty__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Empty__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Empty__Sequence>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__Empty__Sequence))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Empty__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Empty__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Empty__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Float32 {
    pub data: f32,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Float32() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Float32> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Float32>(),
        4usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Float32))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Float32>(),
        4usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__Float32))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Float32),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Float32__Sequence {
    pub data: *mut std_msgs__msg__Float32,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Float32__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Float32__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Float32__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Float32__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Float32__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(std_msgs__msg__Float32__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Float32__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Float32__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Float32__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct std_msgs__msg__Float32MultiArray {
    pub layout: std_msgs__msg__MultiArrayLayout,
    pub data: rosidl_runtime_c__float__Sequence,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Float32MultiArray() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Float32MultiArray> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Float32MultiArray>(),
        56usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Float32MultiArray))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Float32MultiArray>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(std_msgs__msg__Float32MultiArray)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).layout) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Float32MultiArray),
            "::",
            stringify!(layout)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Float32MultiArray),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Float32MultiArray__Sequence {
    pub data: *mut std_msgs__msg__Float32MultiArray,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Float32MultiArray__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Float32MultiArray__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Float32MultiArray__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(std_msgs__msg__Float32MultiArray__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Float32MultiArray__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(std_msgs__msg__Float32MultiArray__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Float32MultiArray__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Float32MultiArray__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Float32MultiArray__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Float64 {
    pub data: f64,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Float64() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Float64> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Float64>(),
        8usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Float64))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Float64>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__Float64))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Float64),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Float64__Sequence {
    pub data: *mut std_msgs__msg__Float64,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Float64__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Float64__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Float64__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Float64__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Float64__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(std_msgs__msg__Float64__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Float64__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Float64__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Float64__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct std_msgs__msg__Float64MultiArray {
    pub layout: std_msgs__msg__MultiArrayLayout,
    pub data: rosidl_runtime_c__double__Sequence,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Float64MultiArray() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Float64MultiArray> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Float64MultiArray>(),
        56usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Float64MultiArray))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Float64MultiArray>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(std_msgs__msg__Float64MultiArray)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).layout) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Float64MultiArray),
            "::",
            stringify!(layout)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Float64MultiArray),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Float64MultiArray__Sequence {
    pub data: *mut std_msgs__msg__Float64MultiArray,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Float64MultiArray__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Float64MultiArray__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Float64MultiArray__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(std_msgs__msg__Float64MultiArray__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Float64MultiArray__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(std_msgs__msg__Float64MultiArray__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Float64MultiArray__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Float64MultiArray__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Float64MultiArray__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Int16 {
    pub data: i16,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Int16() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Int16> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Int16>(),
        2usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Int16))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Int16>(),
        2usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__Int16))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int16),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Int16__Sequence {
    pub data: *mut std_msgs__msg__Int16,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Int16__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Int16__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Int16__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Int16__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Int16__Sequence>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__Int16__Sequence))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int16__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int16__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int16__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct std_msgs__msg__Int16MultiArray {
    pub layout: std_msgs__msg__MultiArrayLayout,
    pub data: rosidl_runtime_c__int16__Sequence,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Int16MultiArray() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Int16MultiArray> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Int16MultiArray>(),
        56usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Int16MultiArray))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Int16MultiArray>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__Int16MultiArray))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).layout) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int16MultiArray),
            "::",
            stringify!(layout)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int16MultiArray),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Int16MultiArray__Sequence {
    pub data: *mut std_msgs__msg__Int16MultiArray,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Int16MultiArray__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Int16MultiArray__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Int16MultiArray__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(std_msgs__msg__Int16MultiArray__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Int16MultiArray__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(std_msgs__msg__Int16MultiArray__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int16MultiArray__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int16MultiArray__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int16MultiArray__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Int32 {
    pub data: i32,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Int32() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Int32> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Int32>(),
        4usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Int32))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Int32>(),
        4usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__Int32))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int32),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Int32__Sequence {
    pub data: *mut std_msgs__msg__Int32,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Int32__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Int32__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Int32__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Int32__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Int32__Sequence>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__Int32__Sequence))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int32__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int32__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int32__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct std_msgs__msg__Int32MultiArray {
    pub layout: std_msgs__msg__MultiArrayLayout,
    pub data: rosidl_runtime_c__int32__Sequence,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Int32MultiArray() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Int32MultiArray> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Int32MultiArray>(),
        56usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Int32MultiArray))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Int32MultiArray>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__Int32MultiArray))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).layout) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int32MultiArray),
            "::",
            stringify!(layout)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int32MultiArray),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Int32MultiArray__Sequence {
    pub data: *mut std_msgs__msg__Int32MultiArray,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Int32MultiArray__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Int32MultiArray__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Int32MultiArray__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(std_msgs__msg__Int32MultiArray__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Int32MultiArray__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(std_msgs__msg__Int32MultiArray__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int32MultiArray__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int32MultiArray__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int32MultiArray__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Int64 {
    pub data: i64,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Int64() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Int64> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Int64>(),
        8usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Int64))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Int64>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__Int64))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int64),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Int64__Sequence {
    pub data: *mut std_msgs__msg__Int64,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Int64__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Int64__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Int64__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Int64__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Int64__Sequence>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__Int64__Sequence))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int64__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int64__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int64__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct std_msgs__msg__Int64MultiArray {
    pub layout: std_msgs__msg__MultiArrayLayout,
    pub data: rosidl_runtime_c__int64__Sequence,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Int64MultiArray() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Int64MultiArray> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Int64MultiArray>(),
        56usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Int64MultiArray))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Int64MultiArray>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__Int64MultiArray))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).layout) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int64MultiArray),
            "::",
            stringify!(layout)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int64MultiArray),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Int64MultiArray__Sequence {
    pub data: *mut std_msgs__msg__Int64MultiArray,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Int64MultiArray__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Int64MultiArray__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Int64MultiArray__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(std_msgs__msg__Int64MultiArray__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Int64MultiArray__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(std_msgs__msg__Int64MultiArray__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int64MultiArray__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int64MultiArray__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int64MultiArray__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Int8 {
    pub data: i8,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Int8() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Int8> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Int8>(),
        1usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Int8))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Int8>(),
        1usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__Int8))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int8),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Int8__Sequence {
    pub data: *mut std_msgs__msg__Int8,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Int8__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Int8__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Int8__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Int8__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Int8__Sequence>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__Int8__Sequence))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int8__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int8__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int8__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct std_msgs__msg__Int8MultiArray {
    pub layout: std_msgs__msg__MultiArrayLayout,
    pub data: rosidl_runtime_c__int8__Sequence,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Int8MultiArray() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Int8MultiArray> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Int8MultiArray>(),
        56usize,
        concat!("Size of: ", stringify!(std_msgs__msg__Int8MultiArray))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Int8MultiArray>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__Int8MultiArray))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).layout) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int8MultiArray),
            "::",
            stringify!(layout)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int8MultiArray),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__Int8MultiArray__Sequence {
    pub data: *mut std_msgs__msg__Int8MultiArray,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__Int8MultiArray__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__Int8MultiArray__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__Int8MultiArray__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(std_msgs__msg__Int8MultiArray__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__Int8MultiArray__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(std_msgs__msg__Int8MultiArray__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int8MultiArray__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int8MultiArray__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__Int8MultiArray__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct std_msgs__msg__String {
    pub data: rosidl_runtime_c__String,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__String() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__String> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__String>(),
        24usize,
        concat!("Size of: ", stringify!(std_msgs__msg__String))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__String>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__String))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__String),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__String__Sequence {
    pub data: *mut std_msgs__msg__String,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__String__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__String__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__String__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(std_msgs__msg__String__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__String__Sequence>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__String__Sequence))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__String__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__String__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__String__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__UInt16 {
    pub data: u16,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__UInt16() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__UInt16> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__UInt16>(),
        2usize,
        concat!("Size of: ", stringify!(std_msgs__msg__UInt16))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__UInt16>(),
        2usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__UInt16))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt16),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__UInt16__Sequence {
    pub data: *mut std_msgs__msg__UInt16,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__UInt16__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__UInt16__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__UInt16__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(std_msgs__msg__UInt16__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__UInt16__Sequence>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__UInt16__Sequence))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt16__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt16__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt16__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct std_msgs__msg__UInt16MultiArray {
    pub layout: std_msgs__msg__MultiArrayLayout,
    pub data: rosidl_runtime_c__uint16__Sequence,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__UInt16MultiArray() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__UInt16MultiArray> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__UInt16MultiArray>(),
        56usize,
        concat!("Size of: ", stringify!(std_msgs__msg__UInt16MultiArray))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__UInt16MultiArray>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__UInt16MultiArray))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).layout) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt16MultiArray),
            "::",
            stringify!(layout)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt16MultiArray),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__UInt16MultiArray__Sequence {
    pub data: *mut std_msgs__msg__UInt16MultiArray,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__UInt16MultiArray__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__UInt16MultiArray__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__UInt16MultiArray__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(std_msgs__msg__UInt16MultiArray__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__UInt16MultiArray__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(std_msgs__msg__UInt16MultiArray__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt16MultiArray__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt16MultiArray__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt16MultiArray__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__UInt32 {
    pub data: u32,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__UInt32() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__UInt32> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__UInt32>(),
        4usize,
        concat!("Size of: ", stringify!(std_msgs__msg__UInt32))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__UInt32>(),
        4usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__UInt32))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt32),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__UInt32__Sequence {
    pub data: *mut std_msgs__msg__UInt32,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__UInt32__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__UInt32__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__UInt32__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(std_msgs__msg__UInt32__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__UInt32__Sequence>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__UInt32__Sequence))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt32__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt32__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt32__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct std_msgs__msg__UInt32MultiArray {
    pub layout: std_msgs__msg__MultiArrayLayout,
    pub data: rosidl_runtime_c__uint32__Sequence,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__UInt32MultiArray() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__UInt32MultiArray> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__UInt32MultiArray>(),
        56usize,
        concat!("Size of: ", stringify!(std_msgs__msg__UInt32MultiArray))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__UInt32MultiArray>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__UInt32MultiArray))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).layout) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt32MultiArray),
            "::",
            stringify!(layout)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt32MultiArray),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__UInt32MultiArray__Sequence {
    pub data: *mut std_msgs__msg__UInt32MultiArray,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__UInt32MultiArray__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__UInt32MultiArray__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__UInt32MultiArray__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(std_msgs__msg__UInt32MultiArray__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__UInt32MultiArray__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(std_msgs__msg__UInt32MultiArray__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt32MultiArray__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt32MultiArray__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt32MultiArray__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__UInt64 {
    pub data: u64,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__UInt64() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__UInt64> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__UInt64>(),
        8usize,
        concat!("Size of: ", stringify!(std_msgs__msg__UInt64))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__UInt64>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__UInt64))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt64),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__UInt64__Sequence {
    pub data: *mut std_msgs__msg__UInt64,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__UInt64__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__UInt64__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__UInt64__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(std_msgs__msg__UInt64__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__UInt64__Sequence>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__UInt64__Sequence))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt64__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt64__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt64__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct std_msgs__msg__UInt64MultiArray {
    pub layout: std_msgs__msg__MultiArrayLayout,
    pub data: rosidl_runtime_c__uint64__Sequence,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__UInt64MultiArray() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__UInt64MultiArray> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__UInt64MultiArray>(),
        56usize,
        concat!("Size of: ", stringify!(std_msgs__msg__UInt64MultiArray))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__UInt64MultiArray>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__UInt64MultiArray))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).layout) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt64MultiArray),
            "::",
            stringify!(layout)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt64MultiArray),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__UInt64MultiArray__Sequence {
    pub data: *mut std_msgs__msg__UInt64MultiArray,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__UInt64MultiArray__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__UInt64MultiArray__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__UInt64MultiArray__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(std_msgs__msg__UInt64MultiArray__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__UInt64MultiArray__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(std_msgs__msg__UInt64MultiArray__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt64MultiArray__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt64MultiArray__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt64MultiArray__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__UInt8 {
    pub data: u8,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__UInt8() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__UInt8> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__UInt8>(),
        1usize,
        concat!("Size of: ", stringify!(std_msgs__msg__UInt8))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__UInt8>(),
        1usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__UInt8))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt8),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__UInt8__Sequence {
    pub data: *mut std_msgs__msg__UInt8,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__UInt8__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__UInt8__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__UInt8__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(std_msgs__msg__UInt8__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__UInt8__Sequence>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__UInt8__Sequence))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt8__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt8__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt8__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct std_msgs__msg__UInt8MultiArray {
    pub layout: std_msgs__msg__MultiArrayLayout,
    pub data: rosidl_runtime_c__uint8__Sequence,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__UInt8MultiArray() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__UInt8MultiArray> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__UInt8MultiArray>(),
        56usize,
        concat!("Size of: ", stringify!(std_msgs__msg__UInt8MultiArray))
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__UInt8MultiArray>(),
        8usize,
        concat!("Alignment of ", stringify!(std_msgs__msg__UInt8MultiArray))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).layout) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt8MultiArray),
            "::",
            stringify!(layout)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt8MultiArray),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct std_msgs__msg__UInt8MultiArray__Sequence {
    pub data: *mut std_msgs__msg__UInt8MultiArray,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_std_msgs__msg__UInt8MultiArray__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<std_msgs__msg__UInt8MultiArray__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<std_msgs__msg__UInt8MultiArray__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(std_msgs__msg__UInt8MultiArray__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<std_msgs__msg__UInt8MultiArray__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(std_msgs__msg__UInt8MultiArray__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt8MultiArray__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt8MultiArray__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(std_msgs__msg__UInt8MultiArray__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct stereo_msgs__msg__DisparityImage {
    pub header: std_msgs__msg__Header,
    pub image: sensor_msgs__msg__Image,
    pub f: f32,
    pub t: f32,
    pub valid_window: sensor_msgs__msg__RegionOfInterest,
    pub min_disparity: f32,
    pub max_disparity: f32,
    pub delta_d: f32,
}
#[test]
fn bindgen_test_layout_stereo_msgs__msg__DisparityImage() {
    const UNINIT: ::std::mem::MaybeUninit<stereo_msgs__msg__DisparityImage> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<stereo_msgs__msg__DisparityImage>(),
        168usize,
        concat!("Size of: ", stringify!(stereo_msgs__msg__DisparityImage))
    );
    assert_eq!(
        ::std::mem::align_of::<stereo_msgs__msg__DisparityImage>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(stereo_msgs__msg__DisparityImage)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(stereo_msgs__msg__DisparityImage),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).image) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(stereo_msgs__msg__DisparityImage),
            "::",
            stringify!(image)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).f) as usize - ptr as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(stereo_msgs__msg__DisparityImage),
            "::",
            stringify!(f)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).t) as usize - ptr as usize },
        132usize,
        concat!(
            "Offset of field: ",
            stringify!(stereo_msgs__msg__DisparityImage),
            "::",
            stringify!(t)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).valid_window) as usize - ptr as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(stereo_msgs__msg__DisparityImage),
            "::",
            stringify!(valid_window)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).min_disparity) as usize - ptr as usize },
        156usize,
        concat!(
            "Offset of field: ",
            stringify!(stereo_msgs__msg__DisparityImage),
            "::",
            stringify!(min_disparity)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_disparity) as usize - ptr as usize },
        160usize,
        concat!(
            "Offset of field: ",
            stringify!(stereo_msgs__msg__DisparityImage),
            "::",
            stringify!(max_disparity)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).delta_d) as usize - ptr as usize },
        164usize,
        concat!(
            "Offset of field: ",
            stringify!(stereo_msgs__msg__DisparityImage),
            "::",
            stringify!(delta_d)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct stereo_msgs__msg__DisparityImage__Sequence {
    pub data: *mut stereo_msgs__msg__DisparityImage,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_stereo_msgs__msg__DisparityImage__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<stereo_msgs__msg__DisparityImage__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<stereo_msgs__msg__DisparityImage__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(stereo_msgs__msg__DisparityImage__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<stereo_msgs__msg__DisparityImage__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(stereo_msgs__msg__DisparityImage__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(stereo_msgs__msg__DisparityImage__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(stereo_msgs__msg__DisparityImage__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(stereo_msgs__msg__DisparityImage__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__Fibonacci_Goal {
    pub order: i32,
}
#[test]
fn bindgen_test_layout_test_msgs__action__Fibonacci_Goal() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__action__Fibonacci_Goal> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__Fibonacci_Goal>(),
        4usize,
        concat!("Size of: ", stringify!(test_msgs__action__Fibonacci_Goal))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__Fibonacci_Goal>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__Fibonacci_Goal)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).order) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_Goal),
            "::",
            stringify!(order)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__Fibonacci_Goal__Sequence {
    pub data: *mut test_msgs__action__Fibonacci_Goal,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__action__Fibonacci_Goal__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__action__Fibonacci_Goal__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__Fibonacci_Goal__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__Fibonacci_Goal__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__Fibonacci_Goal__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__Fibonacci_Goal__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_Goal__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_Goal__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_Goal__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct test_msgs__action__Fibonacci_Result {
    pub sequence: rosidl_runtime_c__int32__Sequence,
}
#[test]
fn bindgen_test_layout_test_msgs__action__Fibonacci_Result() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__action__Fibonacci_Result> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__Fibonacci_Result>(),
        24usize,
        concat!("Size of: ", stringify!(test_msgs__action__Fibonacci_Result))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__Fibonacci_Result>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__Fibonacci_Result)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sequence) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_Result),
            "::",
            stringify!(sequence)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__Fibonacci_Result__Sequence {
    pub data: *mut test_msgs__action__Fibonacci_Result,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__action__Fibonacci_Result__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__action__Fibonacci_Result__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__Fibonacci_Result__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__Fibonacci_Result__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__Fibonacci_Result__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__Fibonacci_Result__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_Result__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_Result__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_Result__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct test_msgs__action__Fibonacci_Feedback {
    pub sequence: rosidl_runtime_c__int32__Sequence,
}
#[test]
fn bindgen_test_layout_test_msgs__action__Fibonacci_Feedback() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__action__Fibonacci_Feedback> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__Fibonacci_Feedback>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__Fibonacci_Feedback)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__Fibonacci_Feedback>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__Fibonacci_Feedback)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sequence) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_Feedback),
            "::",
            stringify!(sequence)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__Fibonacci_Feedback__Sequence {
    pub data: *mut test_msgs__action__Fibonacci_Feedback,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__action__Fibonacci_Feedback__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__action__Fibonacci_Feedback__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__Fibonacci_Feedback__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__Fibonacci_Feedback__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__Fibonacci_Feedback__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__Fibonacci_Feedback__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_Feedback__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_Feedback__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_Feedback__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__Fibonacci_SendGoal_Request {
    pub goal_id: unique_identifier_msgs__msg__UUID,
    pub goal: test_msgs__action__Fibonacci_Goal,
}
#[test]
fn bindgen_test_layout_test_msgs__action__Fibonacci_SendGoal_Request() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__action__Fibonacci_SendGoal_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__Fibonacci_SendGoal_Request>(),
        20usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__Fibonacci_SendGoal_Request)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__Fibonacci_SendGoal_Request>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__Fibonacci_SendGoal_Request)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).goal_id) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_SendGoal_Request),
            "::",
            stringify!(goal_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).goal) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_SendGoal_Request),
            "::",
            stringify!(goal)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__Fibonacci_SendGoal_Request__Sequence {
    pub data: *mut test_msgs__action__Fibonacci_SendGoal_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__action__Fibonacci_SendGoal_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__action__Fibonacci_SendGoal_Request__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__Fibonacci_SendGoal_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__Fibonacci_SendGoal_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__Fibonacci_SendGoal_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__Fibonacci_SendGoal_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_SendGoal_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_SendGoal_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_SendGoal_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__Fibonacci_SendGoal_Response {
    pub accepted: bool,
    pub stamp: builtin_interfaces__msg__Time,
}
#[test]
fn bindgen_test_layout_test_msgs__action__Fibonacci_SendGoal_Response() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__action__Fibonacci_SendGoal_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__Fibonacci_SendGoal_Response>(),
        12usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__Fibonacci_SendGoal_Response)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__Fibonacci_SendGoal_Response>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__Fibonacci_SendGoal_Response)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).accepted) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_SendGoal_Response),
            "::",
            stringify!(accepted)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).stamp) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_SendGoal_Response),
            "::",
            stringify!(stamp)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__Fibonacci_SendGoal_Response__Sequence {
    pub data: *mut test_msgs__action__Fibonacci_SendGoal_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__action__Fibonacci_SendGoal_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        test_msgs__action__Fibonacci_SendGoal_Response__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__Fibonacci_SendGoal_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__Fibonacci_SendGoal_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__Fibonacci_SendGoal_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__Fibonacci_SendGoal_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_SendGoal_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_SendGoal_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_SendGoal_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__Fibonacci_GetResult_Request {
    pub goal_id: unique_identifier_msgs__msg__UUID,
}
#[test]
fn bindgen_test_layout_test_msgs__action__Fibonacci_GetResult_Request() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__action__Fibonacci_GetResult_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__Fibonacci_GetResult_Request>(),
        16usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__Fibonacci_GetResult_Request)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__Fibonacci_GetResult_Request>(),
        1usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__Fibonacci_GetResult_Request)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).goal_id) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_GetResult_Request),
            "::",
            stringify!(goal_id)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__Fibonacci_GetResult_Request__Sequence {
    pub data: *mut test_msgs__action__Fibonacci_GetResult_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__action__Fibonacci_GetResult_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        test_msgs__action__Fibonacci_GetResult_Request__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__Fibonacci_GetResult_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__Fibonacci_GetResult_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__Fibonacci_GetResult_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__Fibonacci_GetResult_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_GetResult_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_GetResult_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_GetResult_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct test_msgs__action__Fibonacci_GetResult_Response {
    pub status: i8,
    pub result: test_msgs__action__Fibonacci_Result,
}
#[test]
fn bindgen_test_layout_test_msgs__action__Fibonacci_GetResult_Response() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__action__Fibonacci_GetResult_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__Fibonacci_GetResult_Response>(),
        32usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__Fibonacci_GetResult_Response)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__Fibonacci_GetResult_Response>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__Fibonacci_GetResult_Response)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).status) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_GetResult_Response),
            "::",
            stringify!(status)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).result) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_GetResult_Response),
            "::",
            stringify!(result)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__Fibonacci_GetResult_Response__Sequence {
    pub data: *mut test_msgs__action__Fibonacci_GetResult_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__action__Fibonacci_GetResult_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        test_msgs__action__Fibonacci_GetResult_Response__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__Fibonacci_GetResult_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__Fibonacci_GetResult_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__Fibonacci_GetResult_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__Fibonacci_GetResult_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_GetResult_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_GetResult_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_GetResult_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct test_msgs__action__Fibonacci_FeedbackMessage {
    pub goal_id: unique_identifier_msgs__msg__UUID,
    pub feedback: test_msgs__action__Fibonacci_Feedback,
}
#[test]
fn bindgen_test_layout_test_msgs__action__Fibonacci_FeedbackMessage() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__action__Fibonacci_FeedbackMessage> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__Fibonacci_FeedbackMessage>(),
        40usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__Fibonacci_FeedbackMessage)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__Fibonacci_FeedbackMessage>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__Fibonacci_FeedbackMessage)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).goal_id) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_FeedbackMessage),
            "::",
            stringify!(goal_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).feedback) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_FeedbackMessage),
            "::",
            stringify!(feedback)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__Fibonacci_FeedbackMessage__Sequence {
    pub data: *mut test_msgs__action__Fibonacci_FeedbackMessage,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__action__Fibonacci_FeedbackMessage__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__action__Fibonacci_FeedbackMessage__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__Fibonacci_FeedbackMessage__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__Fibonacci_FeedbackMessage__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__Fibonacci_FeedbackMessage__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__Fibonacci_FeedbackMessage__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_FeedbackMessage__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_FeedbackMessage__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__Fibonacci_FeedbackMessage__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__msg__Builtins {
    pub duration_value: builtin_interfaces__msg__Duration,
    pub time_value: builtin_interfaces__msg__Time,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__Builtins() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__Builtins> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__Builtins>(),
        16usize,
        concat!("Size of: ", stringify!(test_msgs__msg__Builtins))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__Builtins>(),
        4usize,
        concat!("Alignment of ", stringify!(test_msgs__msg__Builtins))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).duration_value) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Builtins),
            "::",
            stringify!(duration_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).time_value) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Builtins),
            "::",
            stringify!(time_value)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__msg__Builtins__Sequence {
    pub data: *mut test_msgs__msg__Builtins,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__Builtins__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__Builtins__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__Builtins__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(test_msgs__msg__Builtins__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__Builtins__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__msg__Builtins__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Builtins__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Builtins__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Builtins__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__msg__BasicTypes {
    pub bool_value: bool,
    pub byte_value: u8,
    pub char_value: u8,
    pub float32_value: f32,
    pub float64_value: f64,
    pub int8_value: i8,
    pub uint8_value: u8,
    pub int16_value: i16,
    pub uint16_value: u16,
    pub int32_value: i32,
    pub uint32_value: u32,
    pub int64_value: i64,
    pub uint64_value: u64,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__BasicTypes() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__BasicTypes> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__BasicTypes>(),
        48usize,
        concat!("Size of: ", stringify!(test_msgs__msg__BasicTypes))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__BasicTypes>(),
        8usize,
        concat!("Alignment of ", stringify!(test_msgs__msg__BasicTypes))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bool_value) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BasicTypes),
            "::",
            stringify!(bool_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).byte_value) as usize - ptr as usize },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BasicTypes),
            "::",
            stringify!(byte_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).char_value) as usize - ptr as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BasicTypes),
            "::",
            stringify!(char_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float32_value) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BasicTypes),
            "::",
            stringify!(float32_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float64_value) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BasicTypes),
            "::",
            stringify!(float64_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int8_value) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BasicTypes),
            "::",
            stringify!(int8_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint8_value) as usize - ptr as usize },
        17usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BasicTypes),
            "::",
            stringify!(uint8_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int16_value) as usize - ptr as usize },
        18usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BasicTypes),
            "::",
            stringify!(int16_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint16_value) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BasicTypes),
            "::",
            stringify!(uint16_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int32_value) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BasicTypes),
            "::",
            stringify!(int32_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint32_value) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BasicTypes),
            "::",
            stringify!(uint32_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int64_value) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BasicTypes),
            "::",
            stringify!(int64_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint64_value) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BasicTypes),
            "::",
            stringify!(uint64_value)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__msg__BasicTypes__Sequence {
    pub data: *mut test_msgs__msg__BasicTypes,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__BasicTypes__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__BasicTypes__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__BasicTypes__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__msg__BasicTypes__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__BasicTypes__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__msg__BasicTypes__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BasicTypes__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BasicTypes__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BasicTypes__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__NestedMessage_Goal {
    pub nested_field_no_pkg: test_msgs__msg__Builtins,
    pub nested_field: test_msgs__msg__BasicTypes,
    pub nested_different_pkg: builtin_interfaces__msg__Time,
}
#[test]
fn bindgen_test_layout_test_msgs__action__NestedMessage_Goal() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__action__NestedMessage_Goal> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__NestedMessage_Goal>(),
        72usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__NestedMessage_Goal)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__NestedMessage_Goal>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__NestedMessage_Goal)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nested_field_no_pkg) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_Goal),
            "::",
            stringify!(nested_field_no_pkg)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nested_field) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_Goal),
            "::",
            stringify!(nested_field)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nested_different_pkg) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_Goal),
            "::",
            stringify!(nested_different_pkg)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__NestedMessage_Goal__Sequence {
    pub data: *mut test_msgs__action__NestedMessage_Goal,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__action__NestedMessage_Goal__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__action__NestedMessage_Goal__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__NestedMessage_Goal__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__NestedMessage_Goal__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__NestedMessage_Goal__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__NestedMessage_Goal__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_Goal__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_Goal__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_Goal__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__NestedMessage_Result {
    pub nested_field_no_pkg: test_msgs__msg__Builtins,
    pub nested_field: test_msgs__msg__BasicTypes,
    pub nested_different_pkg: builtin_interfaces__msg__Time,
}
#[test]
fn bindgen_test_layout_test_msgs__action__NestedMessage_Result() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__action__NestedMessage_Result> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__NestedMessage_Result>(),
        72usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__NestedMessage_Result)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__NestedMessage_Result>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__NestedMessage_Result)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nested_field_no_pkg) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_Result),
            "::",
            stringify!(nested_field_no_pkg)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nested_field) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_Result),
            "::",
            stringify!(nested_field)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nested_different_pkg) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_Result),
            "::",
            stringify!(nested_different_pkg)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__NestedMessage_Result__Sequence {
    pub data: *mut test_msgs__action__NestedMessage_Result,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__action__NestedMessage_Result__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__action__NestedMessage_Result__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__NestedMessage_Result__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__NestedMessage_Result__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__NestedMessage_Result__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__NestedMessage_Result__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_Result__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_Result__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_Result__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__NestedMessage_Feedback {
    pub nested_field_no_pkg: test_msgs__msg__Builtins,
    pub nested_field: test_msgs__msg__BasicTypes,
    pub nested_different_pkg: builtin_interfaces__msg__Time,
}
#[test]
fn bindgen_test_layout_test_msgs__action__NestedMessage_Feedback() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__action__NestedMessage_Feedback> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__NestedMessage_Feedback>(),
        72usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__NestedMessage_Feedback)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__NestedMessage_Feedback>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__NestedMessage_Feedback)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nested_field_no_pkg) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_Feedback),
            "::",
            stringify!(nested_field_no_pkg)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nested_field) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_Feedback),
            "::",
            stringify!(nested_field)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).nested_different_pkg) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_Feedback),
            "::",
            stringify!(nested_different_pkg)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__NestedMessage_Feedback__Sequence {
    pub data: *mut test_msgs__action__NestedMessage_Feedback,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__action__NestedMessage_Feedback__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__action__NestedMessage_Feedback__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__NestedMessage_Feedback__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__NestedMessage_Feedback__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__NestedMessage_Feedback__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__NestedMessage_Feedback__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_Feedback__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_Feedback__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_Feedback__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__NestedMessage_SendGoal_Request {
    pub goal_id: unique_identifier_msgs__msg__UUID,
    pub goal: test_msgs__action__NestedMessage_Goal,
}
#[test]
fn bindgen_test_layout_test_msgs__action__NestedMessage_SendGoal_Request() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__action__NestedMessage_SendGoal_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__NestedMessage_SendGoal_Request>(),
        88usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__NestedMessage_SendGoal_Request)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__NestedMessage_SendGoal_Request>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__NestedMessage_SendGoal_Request)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).goal_id) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_SendGoal_Request),
            "::",
            stringify!(goal_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).goal) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_SendGoal_Request),
            "::",
            stringify!(goal)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__NestedMessage_SendGoal_Request__Sequence {
    pub data: *mut test_msgs__action__NestedMessage_SendGoal_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__action__NestedMessage_SendGoal_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        test_msgs__action__NestedMessage_SendGoal_Request__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__NestedMessage_SendGoal_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__NestedMessage_SendGoal_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__NestedMessage_SendGoal_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__NestedMessage_SendGoal_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_SendGoal_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_SendGoal_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_SendGoal_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__NestedMessage_SendGoal_Response {
    pub accepted: bool,
    pub stamp: builtin_interfaces__msg__Time,
}
#[test]
fn bindgen_test_layout_test_msgs__action__NestedMessage_SendGoal_Response() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__action__NestedMessage_SendGoal_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__NestedMessage_SendGoal_Response>(),
        12usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__NestedMessage_SendGoal_Response)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__NestedMessage_SendGoal_Response>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__NestedMessage_SendGoal_Response)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).accepted) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_SendGoal_Response),
            "::",
            stringify!(accepted)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).stamp) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_SendGoal_Response),
            "::",
            stringify!(stamp)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__NestedMessage_SendGoal_Response__Sequence {
    pub data: *mut test_msgs__action__NestedMessage_SendGoal_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__action__NestedMessage_SendGoal_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        test_msgs__action__NestedMessage_SendGoal_Response__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__NestedMessage_SendGoal_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__NestedMessage_SendGoal_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__NestedMessage_SendGoal_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__NestedMessage_SendGoal_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_SendGoal_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_SendGoal_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_SendGoal_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__NestedMessage_GetResult_Request {
    pub goal_id: unique_identifier_msgs__msg__UUID,
}
#[test]
fn bindgen_test_layout_test_msgs__action__NestedMessage_GetResult_Request() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__action__NestedMessage_GetResult_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__NestedMessage_GetResult_Request>(),
        16usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__NestedMessage_GetResult_Request)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__NestedMessage_GetResult_Request>(),
        1usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__NestedMessage_GetResult_Request)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).goal_id) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_GetResult_Request),
            "::",
            stringify!(goal_id)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__NestedMessage_GetResult_Request__Sequence {
    pub data: *mut test_msgs__action__NestedMessage_GetResult_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__action__NestedMessage_GetResult_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        test_msgs__action__NestedMessage_GetResult_Request__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__NestedMessage_GetResult_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__NestedMessage_GetResult_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__NestedMessage_GetResult_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__NestedMessage_GetResult_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_GetResult_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_GetResult_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_GetResult_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__NestedMessage_GetResult_Response {
    pub status: i8,
    pub result: test_msgs__action__NestedMessage_Result,
}
#[test]
fn bindgen_test_layout_test_msgs__action__NestedMessage_GetResult_Response() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__action__NestedMessage_GetResult_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__NestedMessage_GetResult_Response>(),
        80usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__NestedMessage_GetResult_Response)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__NestedMessage_GetResult_Response>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__NestedMessage_GetResult_Response)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).status) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_GetResult_Response),
            "::",
            stringify!(status)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).result) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_GetResult_Response),
            "::",
            stringify!(result)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__NestedMessage_GetResult_Response__Sequence {
    pub data: *mut test_msgs__action__NestedMessage_GetResult_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__action__NestedMessage_GetResult_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        test_msgs__action__NestedMessage_GetResult_Response__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__NestedMessage_GetResult_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__NestedMessage_GetResult_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__NestedMessage_GetResult_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__NestedMessage_GetResult_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_GetResult_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_GetResult_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_GetResult_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__NestedMessage_FeedbackMessage {
    pub goal_id: unique_identifier_msgs__msg__UUID,
    pub feedback: test_msgs__action__NestedMessage_Feedback,
}
#[test]
fn bindgen_test_layout_test_msgs__action__NestedMessage_FeedbackMessage() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__action__NestedMessage_FeedbackMessage> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__NestedMessage_FeedbackMessage>(),
        88usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__NestedMessage_FeedbackMessage)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__NestedMessage_FeedbackMessage>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__NestedMessage_FeedbackMessage)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).goal_id) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_FeedbackMessage),
            "::",
            stringify!(goal_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).feedback) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_FeedbackMessage),
            "::",
            stringify!(feedback)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__action__NestedMessage_FeedbackMessage__Sequence {
    pub data: *mut test_msgs__action__NestedMessage_FeedbackMessage,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__action__NestedMessage_FeedbackMessage__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        test_msgs__action__NestedMessage_FeedbackMessage__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__action__NestedMessage_FeedbackMessage__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__action__NestedMessage_FeedbackMessage__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__action__NestedMessage_FeedbackMessage__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__action__NestedMessage_FeedbackMessage__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_FeedbackMessage__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_FeedbackMessage__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__action__NestedMessage_FeedbackMessage__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const test_msgs__msg__Constants__BOOL_CONST: bool = true;
pub const test_msgs__msg__Constants__BYTE_CONST: _bindgen_ty_147 =
    _bindgen_ty_147::test_msgs__msg__Constants__BYTE_CONST;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_147 {
    test_msgs__msg__Constants__BYTE_CONST = 50,
}
pub const test_msgs__msg__Constants__CHAR_CONST: _bindgen_ty_148 =
    _bindgen_ty_148::test_msgs__msg__Constants__CHAR_CONST;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_148 {
    test_msgs__msg__Constants__CHAR_CONST = 100,
}
pub const test_msgs__msg__Constants__FLOAT32_CONST: f32 = 1.125;
pub const test_msgs__msg__Constants__FLOAT64_CONST: f64 = 1.125;
pub const test_msgs__msg__Constants__INT8_CONST: _bindgen_ty_149 =
    _bindgen_ty_149::test_msgs__msg__Constants__INT8_CONST;
#[repr(i32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_149 {
    test_msgs__msg__Constants__INT8_CONST = -50,
}
pub const test_msgs__msg__Constants__UINT8_CONST: _bindgen_ty_150 =
    _bindgen_ty_150::test_msgs__msg__Constants__UINT8_CONST;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_150 {
    test_msgs__msg__Constants__UINT8_CONST = 200,
}
pub const test_msgs__msg__Constants__INT16_CONST: _bindgen_ty_151 =
    _bindgen_ty_151::test_msgs__msg__Constants__INT16_CONST;
#[repr(i32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_151 {
    test_msgs__msg__Constants__INT16_CONST = -1000,
}
pub const test_msgs__msg__Constants__UINT16_CONST: _bindgen_ty_152 =
    _bindgen_ty_152::test_msgs__msg__Constants__UINT16_CONST;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_152 {
    test_msgs__msg__Constants__UINT16_CONST = 2000,
}
pub const test_msgs__msg__Constants__INT32_CONST: _bindgen_ty_153 =
    _bindgen_ty_153::test_msgs__msg__Constants__INT32_CONST;
#[repr(i32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_153 {
    test_msgs__msg__Constants__INT32_CONST = -30000,
}
pub const test_msgs__msg__Constants__UINT32_CONST: _bindgen_ty_154 =
    _bindgen_ty_154::test_msgs__msg__Constants__UINT32_CONST;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_154 {
    test_msgs__msg__Constants__UINT32_CONST = 60000,
}
pub const test_msgs__msg__Constants__INT64_CONST: _bindgen_ty_155 =
    _bindgen_ty_155::test_msgs__msg__Constants__INT64_CONST;
#[repr(i32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_155 {
    test_msgs__msg__Constants__INT64_CONST = -40000000,
}
pub const test_msgs__msg__Constants__UINT64_CONST: _bindgen_ty_156 =
    _bindgen_ty_156::test_msgs__msg__Constants__UINT64_CONST;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_156 {
    test_msgs__msg__Constants__UINT64_CONST = 50000000,
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__msg__Constants {
    pub structure_needs_at_least_one_member: u8,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__Constants() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__Constants> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__Constants>(),
        1usize,
        concat!("Size of: ", stringify!(test_msgs__msg__Constants))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__Constants>(),
        1usize,
        concat!("Alignment of ", stringify!(test_msgs__msg__Constants))
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).structure_needs_at_least_one_member) as usize - ptr as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Constants),
            "::",
            stringify!(structure_needs_at_least_one_member)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__msg__Constants__Sequence {
    pub data: *mut test_msgs__msg__Constants,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__Constants__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__Constants__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__Constants__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(test_msgs__msg__Constants__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__Constants__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__msg__Constants__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Constants__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Constants__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Constants__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__msg__Defaults {
    pub bool_value: bool,
    pub byte_value: u8,
    pub char_value: u8,
    pub float32_value: f32,
    pub float64_value: f64,
    pub int8_value: i8,
    pub uint8_value: u8,
    pub int16_value: i16,
    pub uint16_value: u16,
    pub int32_value: i32,
    pub uint32_value: u32,
    pub int64_value: i64,
    pub uint64_value: u64,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__Defaults() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__Defaults> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__Defaults>(),
        48usize,
        concat!("Size of: ", stringify!(test_msgs__msg__Defaults))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__Defaults>(),
        8usize,
        concat!("Alignment of ", stringify!(test_msgs__msg__Defaults))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bool_value) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Defaults),
            "::",
            stringify!(bool_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).byte_value) as usize - ptr as usize },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Defaults),
            "::",
            stringify!(byte_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).char_value) as usize - ptr as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Defaults),
            "::",
            stringify!(char_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float32_value) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Defaults),
            "::",
            stringify!(float32_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float64_value) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Defaults),
            "::",
            stringify!(float64_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int8_value) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Defaults),
            "::",
            stringify!(int8_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint8_value) as usize - ptr as usize },
        17usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Defaults),
            "::",
            stringify!(uint8_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int16_value) as usize - ptr as usize },
        18usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Defaults),
            "::",
            stringify!(int16_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint16_value) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Defaults),
            "::",
            stringify!(uint16_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int32_value) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Defaults),
            "::",
            stringify!(int32_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint32_value) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Defaults),
            "::",
            stringify!(uint32_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int64_value) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Defaults),
            "::",
            stringify!(int64_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint64_value) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Defaults),
            "::",
            stringify!(uint64_value)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__msg__Defaults__Sequence {
    pub data: *mut test_msgs__msg__Defaults,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__Defaults__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__Defaults__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__Defaults__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(test_msgs__msg__Defaults__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__Defaults__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__msg__Defaults__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Defaults__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Defaults__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Defaults__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct test_msgs__msg__Arrays {
    pub bool_values: [bool; 3usize],
    pub byte_values: [u8; 3usize],
    pub char_values: [u8; 3usize],
    pub float32_values: [f32; 3usize],
    pub float64_values: [f64; 3usize],
    pub int8_values: [i8; 3usize],
    pub uint8_values: [u8; 3usize],
    pub int16_values: [i16; 3usize],
    pub uint16_values: [u16; 3usize],
    pub int32_values: [i32; 3usize],
    pub uint32_values: [u32; 3usize],
    pub int64_values: [i64; 3usize],
    pub uint64_values: [u64; 3usize],
    pub string_values: [rosidl_runtime_c__String; 3usize],
    pub basic_types_values: [test_msgs__msg__BasicTypes; 3usize],
    pub constants_values: [test_msgs__msg__Constants; 3usize],
    pub defaults_values: [test_msgs__msg__Defaults; 3usize],
    pub bool_values_default: [bool; 3usize],
    pub byte_values_default: [u8; 3usize],
    pub char_values_default: [u8; 3usize],
    pub float32_values_default: [f32; 3usize],
    pub float64_values_default: [f64; 3usize],
    pub int8_values_default: [i8; 3usize],
    pub uint8_values_default: [u8; 3usize],
    pub int16_values_default: [i16; 3usize],
    pub uint16_values_default: [u16; 3usize],
    pub int32_values_default: [i32; 3usize],
    pub uint32_values_default: [u32; 3usize],
    pub int64_values_default: [i64; 3usize],
    pub uint64_values_default: [u64; 3usize],
    pub string_values_default: [rosidl_runtime_c__String; 3usize],
    pub alignment_check: i32,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__Arrays() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__Arrays> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__Arrays>(),
        736usize,
        concat!("Size of: ", stringify!(test_msgs__msg__Arrays))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__Arrays>(),
        8usize,
        concat!("Alignment of ", stringify!(test_msgs__msg__Arrays))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bool_values) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(bool_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).byte_values) as usize - ptr as usize },
        3usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(byte_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).char_values) as usize - ptr as usize },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(char_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float32_values) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(float32_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float64_values) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(float64_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int8_values) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(int8_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint8_values) as usize - ptr as usize },
        51usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(uint8_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int16_values) as usize - ptr as usize },
        54usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(int16_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint16_values) as usize - ptr as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(uint16_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int32_values) as usize - ptr as usize },
        68usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(int32_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint32_values) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(uint32_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int64_values) as usize - ptr as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(int64_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint64_values) as usize - ptr as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(uint64_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).string_values) as usize - ptr as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(string_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).basic_types_values) as usize - ptr as usize },
        216usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(basic_types_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).constants_values) as usize - ptr as usize },
        360usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(constants_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).defaults_values) as usize - ptr as usize },
        368usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(defaults_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bool_values_default) as usize - ptr as usize },
        512usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(bool_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).byte_values_default) as usize - ptr as usize },
        515usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(byte_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).char_values_default) as usize - ptr as usize },
        518usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(char_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float32_values_default) as usize - ptr as usize },
        524usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(float32_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float64_values_default) as usize - ptr as usize },
        536usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(float64_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int8_values_default) as usize - ptr as usize },
        560usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(int8_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint8_values_default) as usize - ptr as usize },
        563usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(uint8_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int16_values_default) as usize - ptr as usize },
        566usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(int16_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint16_values_default) as usize - ptr as usize },
        572usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(uint16_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int32_values_default) as usize - ptr as usize },
        580usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(int32_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint32_values_default) as usize - ptr as usize },
        592usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(uint32_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int64_values_default) as usize - ptr as usize },
        608usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(int64_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint64_values_default) as usize - ptr as usize },
        632usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(uint64_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).string_values_default) as usize - ptr as usize },
        656usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(string_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).alignment_check) as usize - ptr as usize },
        728usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays),
            "::",
            stringify!(alignment_check)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__msg__Arrays__Sequence {
    pub data: *mut test_msgs__msg__Arrays,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__Arrays__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__Arrays__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__Arrays__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(test_msgs__msg__Arrays__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__Arrays__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__msg__Arrays__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Arrays__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const test_msgs__msg__BoundedPlainSequences__bool_values__MAX_SIZE: _bindgen_ty_157 =
    _bindgen_ty_157::test_msgs__msg__BoundedPlainSequences__bool_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_157 {
    test_msgs__msg__BoundedPlainSequences__bool_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__byte_values__MAX_SIZE: _bindgen_ty_158 =
    _bindgen_ty_158::test_msgs__msg__BoundedPlainSequences__byte_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_158 {
    test_msgs__msg__BoundedPlainSequences__byte_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__char_values__MAX_SIZE: _bindgen_ty_159 =
    _bindgen_ty_159::test_msgs__msg__BoundedPlainSequences__char_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_159 {
    test_msgs__msg__BoundedPlainSequences__char_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__float32_values__MAX_SIZE: _bindgen_ty_160 =
    _bindgen_ty_160::test_msgs__msg__BoundedPlainSequences__float32_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_160 {
    test_msgs__msg__BoundedPlainSequences__float32_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__float64_values__MAX_SIZE: _bindgen_ty_161 =
    _bindgen_ty_161::test_msgs__msg__BoundedPlainSequences__float64_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_161 {
    test_msgs__msg__BoundedPlainSequences__float64_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__int8_values__MAX_SIZE: _bindgen_ty_162 =
    _bindgen_ty_162::test_msgs__msg__BoundedPlainSequences__int8_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_162 {
    test_msgs__msg__BoundedPlainSequences__int8_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__uint8_values__MAX_SIZE: _bindgen_ty_163 =
    _bindgen_ty_163::test_msgs__msg__BoundedPlainSequences__uint8_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_163 {
    test_msgs__msg__BoundedPlainSequences__uint8_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__int16_values__MAX_SIZE: _bindgen_ty_164 =
    _bindgen_ty_164::test_msgs__msg__BoundedPlainSequences__int16_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_164 {
    test_msgs__msg__BoundedPlainSequences__int16_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__uint16_values__MAX_SIZE: _bindgen_ty_165 =
    _bindgen_ty_165::test_msgs__msg__BoundedPlainSequences__uint16_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_165 {
    test_msgs__msg__BoundedPlainSequences__uint16_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__int32_values__MAX_SIZE: _bindgen_ty_166 =
    _bindgen_ty_166::test_msgs__msg__BoundedPlainSequences__int32_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_166 {
    test_msgs__msg__BoundedPlainSequences__int32_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__uint32_values__MAX_SIZE: _bindgen_ty_167 =
    _bindgen_ty_167::test_msgs__msg__BoundedPlainSequences__uint32_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_167 {
    test_msgs__msg__BoundedPlainSequences__uint32_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__int64_values__MAX_SIZE: _bindgen_ty_168 =
    _bindgen_ty_168::test_msgs__msg__BoundedPlainSequences__int64_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_168 {
    test_msgs__msg__BoundedPlainSequences__int64_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__uint64_values__MAX_SIZE: _bindgen_ty_169 =
    _bindgen_ty_169::test_msgs__msg__BoundedPlainSequences__uint64_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_169 {
    test_msgs__msg__BoundedPlainSequences__uint64_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__basic_types_values__MAX_SIZE: _bindgen_ty_170 =
    _bindgen_ty_170::test_msgs__msg__BoundedPlainSequences__basic_types_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_170 {
    test_msgs__msg__BoundedPlainSequences__basic_types_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__constants_values__MAX_SIZE: _bindgen_ty_171 =
    _bindgen_ty_171::test_msgs__msg__BoundedPlainSequences__constants_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_171 {
    test_msgs__msg__BoundedPlainSequences__constants_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__defaults_values__MAX_SIZE: _bindgen_ty_172 =
    _bindgen_ty_172::test_msgs__msg__BoundedPlainSequences__defaults_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_172 {
    test_msgs__msg__BoundedPlainSequences__defaults_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__bool_values_default__MAX_SIZE: _bindgen_ty_173 =
    _bindgen_ty_173::test_msgs__msg__BoundedPlainSequences__bool_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_173 {
    test_msgs__msg__BoundedPlainSequences__bool_values_default__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__byte_values_default__MAX_SIZE: _bindgen_ty_174 =
    _bindgen_ty_174::test_msgs__msg__BoundedPlainSequences__byte_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_174 {
    test_msgs__msg__BoundedPlainSequences__byte_values_default__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__char_values_default__MAX_SIZE: _bindgen_ty_175 =
    _bindgen_ty_175::test_msgs__msg__BoundedPlainSequences__char_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_175 {
    test_msgs__msg__BoundedPlainSequences__char_values_default__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__float32_values_default__MAX_SIZE: _bindgen_ty_176 =
    _bindgen_ty_176::test_msgs__msg__BoundedPlainSequences__float32_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_176 {
    test_msgs__msg__BoundedPlainSequences__float32_values_default__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__float64_values_default__MAX_SIZE: _bindgen_ty_177 =
    _bindgen_ty_177::test_msgs__msg__BoundedPlainSequences__float64_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_177 {
    test_msgs__msg__BoundedPlainSequences__float64_values_default__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__int8_values_default__MAX_SIZE: _bindgen_ty_178 =
    _bindgen_ty_178::test_msgs__msg__BoundedPlainSequences__int8_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_178 {
    test_msgs__msg__BoundedPlainSequences__int8_values_default__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__uint8_values_default__MAX_SIZE: _bindgen_ty_179 =
    _bindgen_ty_179::test_msgs__msg__BoundedPlainSequences__uint8_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_179 {
    test_msgs__msg__BoundedPlainSequences__uint8_values_default__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__int16_values_default__MAX_SIZE: _bindgen_ty_180 =
    _bindgen_ty_180::test_msgs__msg__BoundedPlainSequences__int16_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_180 {
    test_msgs__msg__BoundedPlainSequences__int16_values_default__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__uint16_values_default__MAX_SIZE: _bindgen_ty_181 =
    _bindgen_ty_181::test_msgs__msg__BoundedPlainSequences__uint16_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_181 {
    test_msgs__msg__BoundedPlainSequences__uint16_values_default__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__int32_values_default__MAX_SIZE: _bindgen_ty_182 =
    _bindgen_ty_182::test_msgs__msg__BoundedPlainSequences__int32_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_182 {
    test_msgs__msg__BoundedPlainSequences__int32_values_default__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__uint32_values_default__MAX_SIZE: _bindgen_ty_183 =
    _bindgen_ty_183::test_msgs__msg__BoundedPlainSequences__uint32_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_183 {
    test_msgs__msg__BoundedPlainSequences__uint32_values_default__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__int64_values_default__MAX_SIZE: _bindgen_ty_184 =
    _bindgen_ty_184::test_msgs__msg__BoundedPlainSequences__int64_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_184 {
    test_msgs__msg__BoundedPlainSequences__int64_values_default__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedPlainSequences__uint64_values_default__MAX_SIZE: _bindgen_ty_185 =
    _bindgen_ty_185::test_msgs__msg__BoundedPlainSequences__uint64_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_185 {
    test_msgs__msg__BoundedPlainSequences__uint64_values_default__MAX_SIZE = 3,
}
#[repr(C)]
pub struct test_msgs__msg__BoundedPlainSequences {
    pub bool_values: rosidl_runtime_c__boolean__Sequence,
    pub byte_values: rosidl_runtime_c__octet__Sequence,
    pub char_values: rosidl_runtime_c__uint8__Sequence,
    pub float32_values: rosidl_runtime_c__float__Sequence,
    pub float64_values: rosidl_runtime_c__double__Sequence,
    pub int8_values: rosidl_runtime_c__int8__Sequence,
    pub uint8_values: rosidl_runtime_c__uint8__Sequence,
    pub int16_values: rosidl_runtime_c__int16__Sequence,
    pub uint16_values: rosidl_runtime_c__uint16__Sequence,
    pub int32_values: rosidl_runtime_c__int32__Sequence,
    pub uint32_values: rosidl_runtime_c__uint32__Sequence,
    pub int64_values: rosidl_runtime_c__int64__Sequence,
    pub uint64_values: rosidl_runtime_c__uint64__Sequence,
    pub basic_types_values: test_msgs__msg__BasicTypes__Sequence,
    pub constants_values: test_msgs__msg__Constants__Sequence,
    pub defaults_values: test_msgs__msg__Defaults__Sequence,
    pub bool_values_default: rosidl_runtime_c__boolean__Sequence,
    pub byte_values_default: rosidl_runtime_c__octet__Sequence,
    pub char_values_default: rosidl_runtime_c__uint8__Sequence,
    pub float32_values_default: rosidl_runtime_c__float__Sequence,
    pub float64_values_default: rosidl_runtime_c__double__Sequence,
    pub int8_values_default: rosidl_runtime_c__int8__Sequence,
    pub uint8_values_default: rosidl_runtime_c__uint8__Sequence,
    pub int16_values_default: rosidl_runtime_c__int16__Sequence,
    pub uint16_values_default: rosidl_runtime_c__uint16__Sequence,
    pub int32_values_default: rosidl_runtime_c__int32__Sequence,
    pub uint32_values_default: rosidl_runtime_c__uint32__Sequence,
    pub int64_values_default: rosidl_runtime_c__int64__Sequence,
    pub uint64_values_default: rosidl_runtime_c__uint64__Sequence,
    pub alignment_check: i32,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__BoundedPlainSequences() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__BoundedPlainSequences> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__BoundedPlainSequences>(),
        704usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__msg__BoundedPlainSequences)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__BoundedPlainSequences>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__msg__BoundedPlainSequences)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bool_values) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(bool_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).byte_values) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(byte_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).char_values) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(char_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float32_values) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(float32_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float64_values) as usize - ptr as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(float64_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int8_values) as usize - ptr as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(int8_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint8_values) as usize - ptr as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(uint8_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int16_values) as usize - ptr as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(int16_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint16_values) as usize - ptr as usize },
        192usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(uint16_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int32_values) as usize - ptr as usize },
        216usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(int32_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint32_values) as usize - ptr as usize },
        240usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(uint32_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int64_values) as usize - ptr as usize },
        264usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(int64_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint64_values) as usize - ptr as usize },
        288usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(uint64_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).basic_types_values) as usize - ptr as usize },
        312usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(basic_types_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).constants_values) as usize - ptr as usize },
        336usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(constants_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).defaults_values) as usize - ptr as usize },
        360usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(defaults_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bool_values_default) as usize - ptr as usize },
        384usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(bool_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).byte_values_default) as usize - ptr as usize },
        408usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(byte_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).char_values_default) as usize - ptr as usize },
        432usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(char_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float32_values_default) as usize - ptr as usize },
        456usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(float32_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float64_values_default) as usize - ptr as usize },
        480usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(float64_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int8_values_default) as usize - ptr as usize },
        504usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(int8_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint8_values_default) as usize - ptr as usize },
        528usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(uint8_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int16_values_default) as usize - ptr as usize },
        552usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(int16_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint16_values_default) as usize - ptr as usize },
        576usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(uint16_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int32_values_default) as usize - ptr as usize },
        600usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(int32_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint32_values_default) as usize - ptr as usize },
        624usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(uint32_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int64_values_default) as usize - ptr as usize },
        648usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(int64_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint64_values_default) as usize - ptr as usize },
        672usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(uint64_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).alignment_check) as usize - ptr as usize },
        696usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences),
            "::",
            stringify!(alignment_check)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__msg__BoundedPlainSequences__Sequence {
    pub data: *mut test_msgs__msg__BoundedPlainSequences,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__BoundedPlainSequences__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__BoundedPlainSequences__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__BoundedPlainSequences__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__msg__BoundedPlainSequences__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__BoundedPlainSequences__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__msg__BoundedPlainSequences__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedPlainSequences__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const test_msgs__msg__BoundedSequences__bool_values__MAX_SIZE: _bindgen_ty_186 =
    _bindgen_ty_186::test_msgs__msg__BoundedSequences__bool_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_186 {
    test_msgs__msg__BoundedSequences__bool_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__byte_values__MAX_SIZE: _bindgen_ty_187 =
    _bindgen_ty_187::test_msgs__msg__BoundedSequences__byte_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_187 {
    test_msgs__msg__BoundedSequences__byte_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__char_values__MAX_SIZE: _bindgen_ty_188 =
    _bindgen_ty_188::test_msgs__msg__BoundedSequences__char_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_188 {
    test_msgs__msg__BoundedSequences__char_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__float32_values__MAX_SIZE: _bindgen_ty_189 =
    _bindgen_ty_189::test_msgs__msg__BoundedSequences__float32_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_189 {
    test_msgs__msg__BoundedSequences__float32_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__float64_values__MAX_SIZE: _bindgen_ty_190 =
    _bindgen_ty_190::test_msgs__msg__BoundedSequences__float64_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_190 {
    test_msgs__msg__BoundedSequences__float64_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__int8_values__MAX_SIZE: _bindgen_ty_191 =
    _bindgen_ty_191::test_msgs__msg__BoundedSequences__int8_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_191 {
    test_msgs__msg__BoundedSequences__int8_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__uint8_values__MAX_SIZE: _bindgen_ty_192 =
    _bindgen_ty_192::test_msgs__msg__BoundedSequences__uint8_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_192 {
    test_msgs__msg__BoundedSequences__uint8_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__int16_values__MAX_SIZE: _bindgen_ty_193 =
    _bindgen_ty_193::test_msgs__msg__BoundedSequences__int16_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_193 {
    test_msgs__msg__BoundedSequences__int16_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__uint16_values__MAX_SIZE: _bindgen_ty_194 =
    _bindgen_ty_194::test_msgs__msg__BoundedSequences__uint16_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_194 {
    test_msgs__msg__BoundedSequences__uint16_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__int32_values__MAX_SIZE: _bindgen_ty_195 =
    _bindgen_ty_195::test_msgs__msg__BoundedSequences__int32_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_195 {
    test_msgs__msg__BoundedSequences__int32_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__uint32_values__MAX_SIZE: _bindgen_ty_196 =
    _bindgen_ty_196::test_msgs__msg__BoundedSequences__uint32_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_196 {
    test_msgs__msg__BoundedSequences__uint32_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__int64_values__MAX_SIZE: _bindgen_ty_197 =
    _bindgen_ty_197::test_msgs__msg__BoundedSequences__int64_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_197 {
    test_msgs__msg__BoundedSequences__int64_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__uint64_values__MAX_SIZE: _bindgen_ty_198 =
    _bindgen_ty_198::test_msgs__msg__BoundedSequences__uint64_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_198 {
    test_msgs__msg__BoundedSequences__uint64_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__string_values__MAX_SIZE: _bindgen_ty_199 =
    _bindgen_ty_199::test_msgs__msg__BoundedSequences__string_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_199 {
    test_msgs__msg__BoundedSequences__string_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__basic_types_values__MAX_SIZE: _bindgen_ty_200 =
    _bindgen_ty_200::test_msgs__msg__BoundedSequences__basic_types_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_200 {
    test_msgs__msg__BoundedSequences__basic_types_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__constants_values__MAX_SIZE: _bindgen_ty_201 =
    _bindgen_ty_201::test_msgs__msg__BoundedSequences__constants_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_201 {
    test_msgs__msg__BoundedSequences__constants_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__defaults_values__MAX_SIZE: _bindgen_ty_202 =
    _bindgen_ty_202::test_msgs__msg__BoundedSequences__defaults_values__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_202 {
    test_msgs__msg__BoundedSequences__defaults_values__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__bool_values_default__MAX_SIZE: _bindgen_ty_203 =
    _bindgen_ty_203::test_msgs__msg__BoundedSequences__bool_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_203 {
    test_msgs__msg__BoundedSequences__bool_values_default__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__byte_values_default__MAX_SIZE: _bindgen_ty_204 =
    _bindgen_ty_204::test_msgs__msg__BoundedSequences__byte_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_204 {
    test_msgs__msg__BoundedSequences__byte_values_default__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__char_values_default__MAX_SIZE: _bindgen_ty_205 =
    _bindgen_ty_205::test_msgs__msg__BoundedSequences__char_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_205 {
    test_msgs__msg__BoundedSequences__char_values_default__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__float32_values_default__MAX_SIZE: _bindgen_ty_206 =
    _bindgen_ty_206::test_msgs__msg__BoundedSequences__float32_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_206 {
    test_msgs__msg__BoundedSequences__float32_values_default__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__float64_values_default__MAX_SIZE: _bindgen_ty_207 =
    _bindgen_ty_207::test_msgs__msg__BoundedSequences__float64_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_207 {
    test_msgs__msg__BoundedSequences__float64_values_default__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__int8_values_default__MAX_SIZE: _bindgen_ty_208 =
    _bindgen_ty_208::test_msgs__msg__BoundedSequences__int8_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_208 {
    test_msgs__msg__BoundedSequences__int8_values_default__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__uint8_values_default__MAX_SIZE: _bindgen_ty_209 =
    _bindgen_ty_209::test_msgs__msg__BoundedSequences__uint8_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_209 {
    test_msgs__msg__BoundedSequences__uint8_values_default__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__int16_values_default__MAX_SIZE: _bindgen_ty_210 =
    _bindgen_ty_210::test_msgs__msg__BoundedSequences__int16_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_210 {
    test_msgs__msg__BoundedSequences__int16_values_default__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__uint16_values_default__MAX_SIZE: _bindgen_ty_211 =
    _bindgen_ty_211::test_msgs__msg__BoundedSequences__uint16_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_211 {
    test_msgs__msg__BoundedSequences__uint16_values_default__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__int32_values_default__MAX_SIZE: _bindgen_ty_212 =
    _bindgen_ty_212::test_msgs__msg__BoundedSequences__int32_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_212 {
    test_msgs__msg__BoundedSequences__int32_values_default__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__uint32_values_default__MAX_SIZE: _bindgen_ty_213 =
    _bindgen_ty_213::test_msgs__msg__BoundedSequences__uint32_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_213 {
    test_msgs__msg__BoundedSequences__uint32_values_default__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__int64_values_default__MAX_SIZE: _bindgen_ty_214 =
    _bindgen_ty_214::test_msgs__msg__BoundedSequences__int64_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_214 {
    test_msgs__msg__BoundedSequences__int64_values_default__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__uint64_values_default__MAX_SIZE: _bindgen_ty_215 =
    _bindgen_ty_215::test_msgs__msg__BoundedSequences__uint64_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_215 {
    test_msgs__msg__BoundedSequences__uint64_values_default__MAX_SIZE = 3,
}
pub const test_msgs__msg__BoundedSequences__string_values_default__MAX_SIZE: _bindgen_ty_216 =
    _bindgen_ty_216::test_msgs__msg__BoundedSequences__string_values_default__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_216 {
    test_msgs__msg__BoundedSequences__string_values_default__MAX_SIZE = 3,
}
#[repr(C)]
pub struct test_msgs__msg__BoundedSequences {
    pub bool_values: rosidl_runtime_c__boolean__Sequence,
    pub byte_values: rosidl_runtime_c__octet__Sequence,
    pub char_values: rosidl_runtime_c__uint8__Sequence,
    pub float32_values: rosidl_runtime_c__float__Sequence,
    pub float64_values: rosidl_runtime_c__double__Sequence,
    pub int8_values: rosidl_runtime_c__int8__Sequence,
    pub uint8_values: rosidl_runtime_c__uint8__Sequence,
    pub int16_values: rosidl_runtime_c__int16__Sequence,
    pub uint16_values: rosidl_runtime_c__uint16__Sequence,
    pub int32_values: rosidl_runtime_c__int32__Sequence,
    pub uint32_values: rosidl_runtime_c__uint32__Sequence,
    pub int64_values: rosidl_runtime_c__int64__Sequence,
    pub uint64_values: rosidl_runtime_c__uint64__Sequence,
    pub string_values: rosidl_runtime_c__String__Sequence,
    pub basic_types_values: test_msgs__msg__BasicTypes__Sequence,
    pub constants_values: test_msgs__msg__Constants__Sequence,
    pub defaults_values: test_msgs__msg__Defaults__Sequence,
    pub bool_values_default: rosidl_runtime_c__boolean__Sequence,
    pub byte_values_default: rosidl_runtime_c__octet__Sequence,
    pub char_values_default: rosidl_runtime_c__uint8__Sequence,
    pub float32_values_default: rosidl_runtime_c__float__Sequence,
    pub float64_values_default: rosidl_runtime_c__double__Sequence,
    pub int8_values_default: rosidl_runtime_c__int8__Sequence,
    pub uint8_values_default: rosidl_runtime_c__uint8__Sequence,
    pub int16_values_default: rosidl_runtime_c__int16__Sequence,
    pub uint16_values_default: rosidl_runtime_c__uint16__Sequence,
    pub int32_values_default: rosidl_runtime_c__int32__Sequence,
    pub uint32_values_default: rosidl_runtime_c__uint32__Sequence,
    pub int64_values_default: rosidl_runtime_c__int64__Sequence,
    pub uint64_values_default: rosidl_runtime_c__uint64__Sequence,
    pub string_values_default: rosidl_runtime_c__String__Sequence,
    pub alignment_check: i32,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__BoundedSequences() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__BoundedSequences> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__BoundedSequences>(),
        752usize,
        concat!("Size of: ", stringify!(test_msgs__msg__BoundedSequences))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__BoundedSequences>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__msg__BoundedSequences)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bool_values) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(bool_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).byte_values) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(byte_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).char_values) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(char_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float32_values) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(float32_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float64_values) as usize - ptr as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(float64_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int8_values) as usize - ptr as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(int8_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint8_values) as usize - ptr as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(uint8_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int16_values) as usize - ptr as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(int16_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint16_values) as usize - ptr as usize },
        192usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(uint16_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int32_values) as usize - ptr as usize },
        216usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(int32_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint32_values) as usize - ptr as usize },
        240usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(uint32_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int64_values) as usize - ptr as usize },
        264usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(int64_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint64_values) as usize - ptr as usize },
        288usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(uint64_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).string_values) as usize - ptr as usize },
        312usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(string_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).basic_types_values) as usize - ptr as usize },
        336usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(basic_types_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).constants_values) as usize - ptr as usize },
        360usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(constants_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).defaults_values) as usize - ptr as usize },
        384usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(defaults_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bool_values_default) as usize - ptr as usize },
        408usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(bool_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).byte_values_default) as usize - ptr as usize },
        432usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(byte_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).char_values_default) as usize - ptr as usize },
        456usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(char_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float32_values_default) as usize - ptr as usize },
        480usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(float32_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float64_values_default) as usize - ptr as usize },
        504usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(float64_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int8_values_default) as usize - ptr as usize },
        528usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(int8_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint8_values_default) as usize - ptr as usize },
        552usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(uint8_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int16_values_default) as usize - ptr as usize },
        576usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(int16_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint16_values_default) as usize - ptr as usize },
        600usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(uint16_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int32_values_default) as usize - ptr as usize },
        624usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(int32_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint32_values_default) as usize - ptr as usize },
        648usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(uint32_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int64_values_default) as usize - ptr as usize },
        672usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(int64_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint64_values_default) as usize - ptr as usize },
        696usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(uint64_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).string_values_default) as usize - ptr as usize },
        720usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(string_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).alignment_check) as usize - ptr as usize },
        744usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences),
            "::",
            stringify!(alignment_check)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__msg__BoundedSequences__Sequence {
    pub data: *mut test_msgs__msg__BoundedSequences,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__BoundedSequences__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__BoundedSequences__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__BoundedSequences__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__msg__BoundedSequences__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__BoundedSequences__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__msg__BoundedSequences__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__BoundedSequences__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__msg__Empty {
    pub structure_needs_at_least_one_member: u8,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__Empty() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__Empty> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__Empty>(),
        1usize,
        concat!("Size of: ", stringify!(test_msgs__msg__Empty))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__Empty>(),
        1usize,
        concat!("Alignment of ", stringify!(test_msgs__msg__Empty))
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).structure_needs_at_least_one_member) as usize - ptr as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Empty),
            "::",
            stringify!(structure_needs_at_least_one_member)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__msg__Empty__Sequence {
    pub data: *mut test_msgs__msg__Empty,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__Empty__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__Empty__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__Empty__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(test_msgs__msg__Empty__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__Empty__Sequence>(),
        8usize,
        concat!("Alignment of ", stringify!(test_msgs__msg__Empty__Sequence))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Empty__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Empty__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Empty__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct test_msgs__msg__UnboundedSequences {
    pub bool_values: rosidl_runtime_c__boolean__Sequence,
    pub byte_values: rosidl_runtime_c__octet__Sequence,
    pub char_values: rosidl_runtime_c__uint8__Sequence,
    pub float32_values: rosidl_runtime_c__float__Sequence,
    pub float64_values: rosidl_runtime_c__double__Sequence,
    pub int8_values: rosidl_runtime_c__int8__Sequence,
    pub uint8_values: rosidl_runtime_c__uint8__Sequence,
    pub int16_values: rosidl_runtime_c__int16__Sequence,
    pub uint16_values: rosidl_runtime_c__uint16__Sequence,
    pub int32_values: rosidl_runtime_c__int32__Sequence,
    pub uint32_values: rosidl_runtime_c__uint32__Sequence,
    pub int64_values: rosidl_runtime_c__int64__Sequence,
    pub uint64_values: rosidl_runtime_c__uint64__Sequence,
    pub string_values: rosidl_runtime_c__String__Sequence,
    pub basic_types_values: test_msgs__msg__BasicTypes__Sequence,
    pub constants_values: test_msgs__msg__Constants__Sequence,
    pub defaults_values: test_msgs__msg__Defaults__Sequence,
    pub bool_values_default: rosidl_runtime_c__boolean__Sequence,
    pub byte_values_default: rosidl_runtime_c__octet__Sequence,
    pub char_values_default: rosidl_runtime_c__uint8__Sequence,
    pub float32_values_default: rosidl_runtime_c__float__Sequence,
    pub float64_values_default: rosidl_runtime_c__double__Sequence,
    pub int8_values_default: rosidl_runtime_c__int8__Sequence,
    pub uint8_values_default: rosidl_runtime_c__uint8__Sequence,
    pub int16_values_default: rosidl_runtime_c__int16__Sequence,
    pub uint16_values_default: rosidl_runtime_c__uint16__Sequence,
    pub int32_values_default: rosidl_runtime_c__int32__Sequence,
    pub uint32_values_default: rosidl_runtime_c__uint32__Sequence,
    pub int64_values_default: rosidl_runtime_c__int64__Sequence,
    pub uint64_values_default: rosidl_runtime_c__uint64__Sequence,
    pub string_values_default: rosidl_runtime_c__String__Sequence,
    pub alignment_check: i32,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__UnboundedSequences() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__UnboundedSequences> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__UnboundedSequences>(),
        752usize,
        concat!("Size of: ", stringify!(test_msgs__msg__UnboundedSequences))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__UnboundedSequences>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__msg__UnboundedSequences)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bool_values) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(bool_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).byte_values) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(byte_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).char_values) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(char_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float32_values) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(float32_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float64_values) as usize - ptr as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(float64_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int8_values) as usize - ptr as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(int8_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint8_values) as usize - ptr as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(uint8_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int16_values) as usize - ptr as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(int16_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint16_values) as usize - ptr as usize },
        192usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(uint16_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int32_values) as usize - ptr as usize },
        216usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(int32_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint32_values) as usize - ptr as usize },
        240usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(uint32_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int64_values) as usize - ptr as usize },
        264usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(int64_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint64_values) as usize - ptr as usize },
        288usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(uint64_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).string_values) as usize - ptr as usize },
        312usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(string_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).basic_types_values) as usize - ptr as usize },
        336usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(basic_types_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).constants_values) as usize - ptr as usize },
        360usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(constants_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).defaults_values) as usize - ptr as usize },
        384usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(defaults_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bool_values_default) as usize - ptr as usize },
        408usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(bool_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).byte_values_default) as usize - ptr as usize },
        432usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(byte_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).char_values_default) as usize - ptr as usize },
        456usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(char_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float32_values_default) as usize - ptr as usize },
        480usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(float32_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float64_values_default) as usize - ptr as usize },
        504usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(float64_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int8_values_default) as usize - ptr as usize },
        528usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(int8_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint8_values_default) as usize - ptr as usize },
        552usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(uint8_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int16_values_default) as usize - ptr as usize },
        576usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(int16_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint16_values_default) as usize - ptr as usize },
        600usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(uint16_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int32_values_default) as usize - ptr as usize },
        624usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(int32_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint32_values_default) as usize - ptr as usize },
        648usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(uint32_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int64_values_default) as usize - ptr as usize },
        672usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(int64_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint64_values_default) as usize - ptr as usize },
        696usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(uint64_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).string_values_default) as usize - ptr as usize },
        720usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(string_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).alignment_check) as usize - ptr as usize },
        744usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences),
            "::",
            stringify!(alignment_check)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__msg__UnboundedSequences__Sequence {
    pub data: *mut test_msgs__msg__UnboundedSequences,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__UnboundedSequences__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__UnboundedSequences__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__UnboundedSequences__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__msg__UnboundedSequences__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__UnboundedSequences__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__msg__UnboundedSequences__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__UnboundedSequences__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const test_msgs__msg__MultiNested__bounded_sequence_of_arrays__MAX_SIZE: _bindgen_ty_217 =
    _bindgen_ty_217::test_msgs__msg__MultiNested__bounded_sequence_of_arrays__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_217 {
    test_msgs__msg__MultiNested__bounded_sequence_of_arrays__MAX_SIZE = 3,
}
pub const test_msgs__msg__MultiNested__bounded_sequence_of_bounded_sequences__MAX_SIZE:
    _bindgen_ty_218 =
    _bindgen_ty_218::test_msgs__msg__MultiNested__bounded_sequence_of_bounded_sequences__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_218 {
    test_msgs__msg__MultiNested__bounded_sequence_of_bounded_sequences__MAX_SIZE = 3,
}
pub const test_msgs__msg__MultiNested__bounded_sequence_of_unbounded_sequences__MAX_SIZE:
    _bindgen_ty_219 =
    _bindgen_ty_219::test_msgs__msg__MultiNested__bounded_sequence_of_unbounded_sequences__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_219 {
    test_msgs__msg__MultiNested__bounded_sequence_of_unbounded_sequences__MAX_SIZE = 3,
}
#[repr(C)]
pub struct test_msgs__msg__MultiNested {
    pub array_of_arrays: [test_msgs__msg__Arrays; 3usize],
    pub array_of_bounded_sequences: [test_msgs__msg__BoundedSequences; 3usize],
    pub array_of_unbounded_sequences: [test_msgs__msg__UnboundedSequences; 3usize],
    pub bounded_sequence_of_arrays: test_msgs__msg__Arrays__Sequence,
    pub bounded_sequence_of_bounded_sequences: test_msgs__msg__BoundedSequences__Sequence,
    pub bounded_sequence_of_unbounded_sequences: test_msgs__msg__UnboundedSequences__Sequence,
    pub unbounded_sequence_of_arrays: test_msgs__msg__Arrays__Sequence,
    pub unbounded_sequence_of_bounded_sequences: test_msgs__msg__BoundedSequences__Sequence,
    pub unbounded_sequence_of_unbounded_sequences: test_msgs__msg__UnboundedSequences__Sequence,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__MultiNested() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__MultiNested> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__MultiNested>(),
        6864usize,
        concat!("Size of: ", stringify!(test_msgs__msg__MultiNested))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__MultiNested>(),
        8usize,
        concat!("Alignment of ", stringify!(test_msgs__msg__MultiNested))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).array_of_arrays) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__MultiNested),
            "::",
            stringify!(array_of_arrays)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).array_of_bounded_sequences) as usize - ptr as usize },
        2208usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__MultiNested),
            "::",
            stringify!(array_of_bounded_sequences)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).array_of_unbounded_sequences) as usize - ptr as usize
        },
        4464usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__MultiNested),
            "::",
            stringify!(array_of_unbounded_sequences)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bounded_sequence_of_arrays) as usize - ptr as usize },
        6720usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__MultiNested),
            "::",
            stringify!(bounded_sequence_of_arrays)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).bounded_sequence_of_bounded_sequences) as usize
                - ptr as usize
        },
        6744usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__MultiNested),
            "::",
            stringify!(bounded_sequence_of_bounded_sequences)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).bounded_sequence_of_unbounded_sequences) as usize
                - ptr as usize
        },
        6768usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__MultiNested),
            "::",
            stringify!(bounded_sequence_of_unbounded_sequences)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).unbounded_sequence_of_arrays) as usize - ptr as usize
        },
        6792usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__MultiNested),
            "::",
            stringify!(unbounded_sequence_of_arrays)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).unbounded_sequence_of_bounded_sequences) as usize
                - ptr as usize
        },
        6816usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__MultiNested),
            "::",
            stringify!(unbounded_sequence_of_bounded_sequences)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).unbounded_sequence_of_unbounded_sequences) as usize
                - ptr as usize
        },
        6840usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__MultiNested),
            "::",
            stringify!(unbounded_sequence_of_unbounded_sequences)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__msg__MultiNested__Sequence {
    pub data: *mut test_msgs__msg__MultiNested,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__MultiNested__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__MultiNested__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__MultiNested__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__msg__MultiNested__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__MultiNested__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__msg__MultiNested__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__MultiNested__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__MultiNested__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__MultiNested__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__msg__Nested {
    pub basic_types_value: test_msgs__msg__BasicTypes,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__Nested() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__Nested> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__Nested>(),
        48usize,
        concat!("Size of: ", stringify!(test_msgs__msg__Nested))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__Nested>(),
        8usize,
        concat!("Alignment of ", stringify!(test_msgs__msg__Nested))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).basic_types_value) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Nested),
            "::",
            stringify!(basic_types_value)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__msg__Nested__Sequence {
    pub data: *mut test_msgs__msg__Nested,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__Nested__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__Nested__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__Nested__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(test_msgs__msg__Nested__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__Nested__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__msg__Nested__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Nested__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Nested__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Nested__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const test_msgs__msg__Strings__STRING_CONST: &[u8; 13usize] = b"Hello world!\0";
pub const test_msgs__msg__Strings__bounded_string_value__MAX_STRING_SIZE: _bindgen_ty_220 =
    _bindgen_ty_220::test_msgs__msg__Strings__bounded_string_value__MAX_STRING_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_220 {
    test_msgs__msg__Strings__bounded_string_value__MAX_STRING_SIZE = 22,
}
pub const test_msgs__msg__Strings__bounded_string_value_default1__MAX_STRING_SIZE: _bindgen_ty_221 =
    _bindgen_ty_221::test_msgs__msg__Strings__bounded_string_value_default1__MAX_STRING_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_221 {
    test_msgs__msg__Strings__bounded_string_value_default1__MAX_STRING_SIZE = 22,
}
pub const test_msgs__msg__Strings__bounded_string_value_default2__MAX_STRING_SIZE: _bindgen_ty_222 =
    _bindgen_ty_222::test_msgs__msg__Strings__bounded_string_value_default2__MAX_STRING_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_222 {
    test_msgs__msg__Strings__bounded_string_value_default2__MAX_STRING_SIZE = 22,
}
pub const test_msgs__msg__Strings__bounded_string_value_default3__MAX_STRING_SIZE: _bindgen_ty_223 =
    _bindgen_ty_223::test_msgs__msg__Strings__bounded_string_value_default3__MAX_STRING_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_223 {
    test_msgs__msg__Strings__bounded_string_value_default3__MAX_STRING_SIZE = 22,
}
pub const test_msgs__msg__Strings__bounded_string_value_default4__MAX_STRING_SIZE: _bindgen_ty_224 =
    _bindgen_ty_224::test_msgs__msg__Strings__bounded_string_value_default4__MAX_STRING_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_224 {
    test_msgs__msg__Strings__bounded_string_value_default4__MAX_STRING_SIZE = 22,
}
pub const test_msgs__msg__Strings__bounded_string_value_default5__MAX_STRING_SIZE: _bindgen_ty_225 =
    _bindgen_ty_225::test_msgs__msg__Strings__bounded_string_value_default5__MAX_STRING_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_225 {
    test_msgs__msg__Strings__bounded_string_value_default5__MAX_STRING_SIZE = 22,
}
#[repr(C)]
pub struct test_msgs__msg__Strings {
    pub string_value: rosidl_runtime_c__String,
    pub string_value_default1: rosidl_runtime_c__String,
    pub string_value_default2: rosidl_runtime_c__String,
    pub string_value_default3: rosidl_runtime_c__String,
    pub string_value_default4: rosidl_runtime_c__String,
    pub string_value_default5: rosidl_runtime_c__String,
    pub bounded_string_value: rosidl_runtime_c__String,
    pub bounded_string_value_default1: rosidl_runtime_c__String,
    pub bounded_string_value_default2: rosidl_runtime_c__String,
    pub bounded_string_value_default3: rosidl_runtime_c__String,
    pub bounded_string_value_default4: rosidl_runtime_c__String,
    pub bounded_string_value_default5: rosidl_runtime_c__String,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__Strings() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__Strings> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__Strings>(),
        288usize,
        concat!("Size of: ", stringify!(test_msgs__msg__Strings))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__Strings>(),
        8usize,
        concat!("Alignment of ", stringify!(test_msgs__msg__Strings))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).string_value) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Strings),
            "::",
            stringify!(string_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).string_value_default1) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Strings),
            "::",
            stringify!(string_value_default1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).string_value_default2) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Strings),
            "::",
            stringify!(string_value_default2)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).string_value_default3) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Strings),
            "::",
            stringify!(string_value_default3)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).string_value_default4) as usize - ptr as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Strings),
            "::",
            stringify!(string_value_default4)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).string_value_default5) as usize - ptr as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Strings),
            "::",
            stringify!(string_value_default5)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bounded_string_value) as usize - ptr as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Strings),
            "::",
            stringify!(bounded_string_value)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).bounded_string_value_default1) as usize - ptr as usize
        },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Strings),
            "::",
            stringify!(bounded_string_value_default1)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).bounded_string_value_default2) as usize - ptr as usize
        },
        192usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Strings),
            "::",
            stringify!(bounded_string_value_default2)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).bounded_string_value_default3) as usize - ptr as usize
        },
        216usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Strings),
            "::",
            stringify!(bounded_string_value_default3)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).bounded_string_value_default4) as usize - ptr as usize
        },
        240usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Strings),
            "::",
            stringify!(bounded_string_value_default4)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).bounded_string_value_default5) as usize - ptr as usize
        },
        264usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Strings),
            "::",
            stringify!(bounded_string_value_default5)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__msg__Strings__Sequence {
    pub data: *mut test_msgs__msg__Strings,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__Strings__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__Strings__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__Strings__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(test_msgs__msg__Strings__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__Strings__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__msg__Strings__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Strings__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Strings__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__Strings__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const test_msgs__msg__WStrings__bounded_sequence_of_wstrings__MAX_SIZE: _bindgen_ty_226 =
    _bindgen_ty_226::test_msgs__msg__WStrings__bounded_sequence_of_wstrings__MAX_SIZE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_226 {
    test_msgs__msg__WStrings__bounded_sequence_of_wstrings__MAX_SIZE = 3,
}
#[repr(C)]
pub struct test_msgs__msg__WStrings {
    pub wstring_value: rosidl_runtime_c__U16String,
    pub wstring_value_default1: rosidl_runtime_c__U16String,
    pub wstring_value_default2: rosidl_runtime_c__U16String,
    pub wstring_value_default3: rosidl_runtime_c__U16String,
    pub array_of_wstrings: [rosidl_runtime_c__U16String; 3usize],
    pub bounded_sequence_of_wstrings: rosidl_runtime_c__U16String__Sequence,
    pub unbounded_sequence_of_wstrings: rosidl_runtime_c__U16String__Sequence,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__WStrings() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__WStrings> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__WStrings>(),
        216usize,
        concat!("Size of: ", stringify!(test_msgs__msg__WStrings))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__WStrings>(),
        8usize,
        concat!("Alignment of ", stringify!(test_msgs__msg__WStrings))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wstring_value) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__WStrings),
            "::",
            stringify!(wstring_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wstring_value_default1) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__WStrings),
            "::",
            stringify!(wstring_value_default1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wstring_value_default2) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__WStrings),
            "::",
            stringify!(wstring_value_default2)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wstring_value_default3) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__WStrings),
            "::",
            stringify!(wstring_value_default3)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).array_of_wstrings) as usize - ptr as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__WStrings),
            "::",
            stringify!(array_of_wstrings)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).bounded_sequence_of_wstrings) as usize - ptr as usize
        },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__WStrings),
            "::",
            stringify!(bounded_sequence_of_wstrings)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).unbounded_sequence_of_wstrings) as usize - ptr as usize
        },
        192usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__WStrings),
            "::",
            stringify!(unbounded_sequence_of_wstrings)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__msg__WStrings__Sequence {
    pub data: *mut test_msgs__msg__WStrings,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__msg__WStrings__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__msg__WStrings__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__msg__WStrings__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(test_msgs__msg__WStrings__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__msg__WStrings__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__msg__WStrings__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__WStrings__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__WStrings__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__msg__WStrings__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct test_msgs__srv__Arrays_Request {
    pub bool_values: [bool; 3usize],
    pub byte_values: [u8; 3usize],
    pub char_values: [u8; 3usize],
    pub float32_values: [f32; 3usize],
    pub float64_values: [f64; 3usize],
    pub int8_values: [i8; 3usize],
    pub uint8_values: [u8; 3usize],
    pub int16_values: [i16; 3usize],
    pub uint16_values: [u16; 3usize],
    pub int32_values: [i32; 3usize],
    pub uint32_values: [u32; 3usize],
    pub int64_values: [i64; 3usize],
    pub uint64_values: [u64; 3usize],
    pub string_values: [rosidl_runtime_c__String; 3usize],
    pub basic_types_values: [test_msgs__msg__BasicTypes; 3usize],
    pub constants_values: [test_msgs__msg__Constants; 3usize],
    pub defaults_values: [test_msgs__msg__Defaults; 3usize],
    pub bool_values_default: [bool; 3usize],
    pub byte_values_default: [u8; 3usize],
    pub char_values_default: [u8; 3usize],
    pub float32_values_default: [f32; 3usize],
    pub float64_values_default: [f64; 3usize],
    pub int8_values_default: [i8; 3usize],
    pub uint8_values_default: [u8; 3usize],
    pub int16_values_default: [i16; 3usize],
    pub uint16_values_default: [u16; 3usize],
    pub int32_values_default: [i32; 3usize],
    pub uint32_values_default: [u32; 3usize],
    pub int64_values_default: [i64; 3usize],
    pub uint64_values_default: [u64; 3usize],
    pub string_values_default: [rosidl_runtime_c__String; 3usize],
}
#[test]
fn bindgen_test_layout_test_msgs__srv__Arrays_Request() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__srv__Arrays_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__srv__Arrays_Request>(),
        728usize,
        concat!("Size of: ", stringify!(test_msgs__srv__Arrays_Request))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__srv__Arrays_Request>(),
        8usize,
        concat!("Alignment of ", stringify!(test_msgs__srv__Arrays_Request))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bool_values) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(bool_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).byte_values) as usize - ptr as usize },
        3usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(byte_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).char_values) as usize - ptr as usize },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(char_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float32_values) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(float32_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float64_values) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(float64_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int8_values) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(int8_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint8_values) as usize - ptr as usize },
        51usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(uint8_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int16_values) as usize - ptr as usize },
        54usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(int16_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint16_values) as usize - ptr as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(uint16_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int32_values) as usize - ptr as usize },
        68usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(int32_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint32_values) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(uint32_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int64_values) as usize - ptr as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(int64_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint64_values) as usize - ptr as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(uint64_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).string_values) as usize - ptr as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(string_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).basic_types_values) as usize - ptr as usize },
        216usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(basic_types_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).constants_values) as usize - ptr as usize },
        360usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(constants_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).defaults_values) as usize - ptr as usize },
        368usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(defaults_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bool_values_default) as usize - ptr as usize },
        512usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(bool_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).byte_values_default) as usize - ptr as usize },
        515usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(byte_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).char_values_default) as usize - ptr as usize },
        518usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(char_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float32_values_default) as usize - ptr as usize },
        524usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(float32_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float64_values_default) as usize - ptr as usize },
        536usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(float64_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int8_values_default) as usize - ptr as usize },
        560usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(int8_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint8_values_default) as usize - ptr as usize },
        563usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(uint8_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int16_values_default) as usize - ptr as usize },
        566usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(int16_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint16_values_default) as usize - ptr as usize },
        572usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(uint16_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int32_values_default) as usize - ptr as usize },
        580usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(int32_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint32_values_default) as usize - ptr as usize },
        592usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(uint32_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int64_values_default) as usize - ptr as usize },
        608usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(int64_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint64_values_default) as usize - ptr as usize },
        632usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(uint64_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).string_values_default) as usize - ptr as usize },
        656usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request),
            "::",
            stringify!(string_values_default)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__srv__Arrays_Request__Sequence {
    pub data: *mut test_msgs__srv__Arrays_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__srv__Arrays_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__srv__Arrays_Request__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__srv__Arrays_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__srv__Arrays_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__srv__Arrays_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__srv__Arrays_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct test_msgs__srv__Arrays_Response {
    pub bool_values: [bool; 3usize],
    pub byte_values: [u8; 3usize],
    pub char_values: [u8; 3usize],
    pub float32_values: [f32; 3usize],
    pub float64_values: [f64; 3usize],
    pub int8_values: [i8; 3usize],
    pub uint8_values: [u8; 3usize],
    pub int16_values: [i16; 3usize],
    pub uint16_values: [u16; 3usize],
    pub int32_values: [i32; 3usize],
    pub uint32_values: [u32; 3usize],
    pub int64_values: [i64; 3usize],
    pub uint64_values: [u64; 3usize],
    pub string_values: [rosidl_runtime_c__String; 3usize],
    pub basic_types_values: [test_msgs__msg__BasicTypes; 3usize],
    pub constants_values: [test_msgs__msg__Constants; 3usize],
    pub defaults_values: [test_msgs__msg__Defaults; 3usize],
    pub bool_values_default: [bool; 3usize],
    pub byte_values_default: [u8; 3usize],
    pub char_values_default: [u8; 3usize],
    pub float32_values_default: [f32; 3usize],
    pub float64_values_default: [f64; 3usize],
    pub int8_values_default: [i8; 3usize],
    pub uint8_values_default: [u8; 3usize],
    pub int16_values_default: [i16; 3usize],
    pub uint16_values_default: [u16; 3usize],
    pub int32_values_default: [i32; 3usize],
    pub uint32_values_default: [u32; 3usize],
    pub int64_values_default: [i64; 3usize],
    pub uint64_values_default: [u64; 3usize],
    pub string_values_default: [rosidl_runtime_c__String; 3usize],
}
#[test]
fn bindgen_test_layout_test_msgs__srv__Arrays_Response() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__srv__Arrays_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__srv__Arrays_Response>(),
        728usize,
        concat!("Size of: ", stringify!(test_msgs__srv__Arrays_Response))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__srv__Arrays_Response>(),
        8usize,
        concat!("Alignment of ", stringify!(test_msgs__srv__Arrays_Response))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bool_values) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(bool_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).byte_values) as usize - ptr as usize },
        3usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(byte_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).char_values) as usize - ptr as usize },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(char_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float32_values) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(float32_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float64_values) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(float64_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int8_values) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(int8_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint8_values) as usize - ptr as usize },
        51usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(uint8_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int16_values) as usize - ptr as usize },
        54usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(int16_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint16_values) as usize - ptr as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(uint16_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int32_values) as usize - ptr as usize },
        68usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(int32_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint32_values) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(uint32_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int64_values) as usize - ptr as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(int64_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint64_values) as usize - ptr as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(uint64_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).string_values) as usize - ptr as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(string_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).basic_types_values) as usize - ptr as usize },
        216usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(basic_types_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).constants_values) as usize - ptr as usize },
        360usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(constants_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).defaults_values) as usize - ptr as usize },
        368usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(defaults_values)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bool_values_default) as usize - ptr as usize },
        512usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(bool_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).byte_values_default) as usize - ptr as usize },
        515usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(byte_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).char_values_default) as usize - ptr as usize },
        518usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(char_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float32_values_default) as usize - ptr as usize },
        524usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(float32_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float64_values_default) as usize - ptr as usize },
        536usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(float64_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int8_values_default) as usize - ptr as usize },
        560usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(int8_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint8_values_default) as usize - ptr as usize },
        563usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(uint8_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int16_values_default) as usize - ptr as usize },
        566usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(int16_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint16_values_default) as usize - ptr as usize },
        572usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(uint16_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int32_values_default) as usize - ptr as usize },
        580usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(int32_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint32_values_default) as usize - ptr as usize },
        592usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(uint32_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int64_values_default) as usize - ptr as usize },
        608usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(int64_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint64_values_default) as usize - ptr as usize },
        632usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(uint64_values_default)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).string_values_default) as usize - ptr as usize },
        656usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response),
            "::",
            stringify!(string_values_default)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__srv__Arrays_Response__Sequence {
    pub data: *mut test_msgs__srv__Arrays_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__srv__Arrays_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__srv__Arrays_Response__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__srv__Arrays_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__srv__Arrays_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__srv__Arrays_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__srv__Arrays_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Arrays_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct test_msgs__srv__BasicTypes_Request {
    pub bool_value: bool,
    pub byte_value: u8,
    pub char_value: u8,
    pub float32_value: f32,
    pub float64_value: f64,
    pub int8_value: i8,
    pub uint8_value: u8,
    pub int16_value: i16,
    pub uint16_value: u16,
    pub int32_value: i32,
    pub uint32_value: u32,
    pub int64_value: i64,
    pub uint64_value: u64,
    pub string_value: rosidl_runtime_c__String,
}
#[test]
fn bindgen_test_layout_test_msgs__srv__BasicTypes_Request() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__srv__BasicTypes_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__srv__BasicTypes_Request>(),
        72usize,
        concat!("Size of: ", stringify!(test_msgs__srv__BasicTypes_Request))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__srv__BasicTypes_Request>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__srv__BasicTypes_Request)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bool_value) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Request),
            "::",
            stringify!(bool_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).byte_value) as usize - ptr as usize },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Request),
            "::",
            stringify!(byte_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).char_value) as usize - ptr as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Request),
            "::",
            stringify!(char_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float32_value) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Request),
            "::",
            stringify!(float32_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float64_value) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Request),
            "::",
            stringify!(float64_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int8_value) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Request),
            "::",
            stringify!(int8_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint8_value) as usize - ptr as usize },
        17usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Request),
            "::",
            stringify!(uint8_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int16_value) as usize - ptr as usize },
        18usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Request),
            "::",
            stringify!(int16_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint16_value) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Request),
            "::",
            stringify!(uint16_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int32_value) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Request),
            "::",
            stringify!(int32_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint32_value) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Request),
            "::",
            stringify!(uint32_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int64_value) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Request),
            "::",
            stringify!(int64_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint64_value) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Request),
            "::",
            stringify!(uint64_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).string_value) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Request),
            "::",
            stringify!(string_value)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__srv__BasicTypes_Request__Sequence {
    pub data: *mut test_msgs__srv__BasicTypes_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__srv__BasicTypes_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__srv__BasicTypes_Request__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__srv__BasicTypes_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__srv__BasicTypes_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__srv__BasicTypes_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__srv__BasicTypes_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct test_msgs__srv__BasicTypes_Response {
    pub bool_value: bool,
    pub byte_value: u8,
    pub char_value: u8,
    pub float32_value: f32,
    pub float64_value: f64,
    pub int8_value: i8,
    pub uint8_value: u8,
    pub int16_value: i16,
    pub uint16_value: u16,
    pub int32_value: i32,
    pub uint32_value: u32,
    pub int64_value: i64,
    pub uint64_value: u64,
    pub string_value: rosidl_runtime_c__String,
}
#[test]
fn bindgen_test_layout_test_msgs__srv__BasicTypes_Response() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__srv__BasicTypes_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__srv__BasicTypes_Response>(),
        72usize,
        concat!("Size of: ", stringify!(test_msgs__srv__BasicTypes_Response))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__srv__BasicTypes_Response>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__srv__BasicTypes_Response)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bool_value) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Response),
            "::",
            stringify!(bool_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).byte_value) as usize - ptr as usize },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Response),
            "::",
            stringify!(byte_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).char_value) as usize - ptr as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Response),
            "::",
            stringify!(char_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float32_value) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Response),
            "::",
            stringify!(float32_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).float64_value) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Response),
            "::",
            stringify!(float64_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int8_value) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Response),
            "::",
            stringify!(int8_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint8_value) as usize - ptr as usize },
        17usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Response),
            "::",
            stringify!(uint8_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int16_value) as usize - ptr as usize },
        18usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Response),
            "::",
            stringify!(int16_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint16_value) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Response),
            "::",
            stringify!(uint16_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int32_value) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Response),
            "::",
            stringify!(int32_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint32_value) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Response),
            "::",
            stringify!(uint32_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).int64_value) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Response),
            "::",
            stringify!(int64_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uint64_value) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Response),
            "::",
            stringify!(uint64_value)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).string_value) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Response),
            "::",
            stringify!(string_value)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__srv__BasicTypes_Response__Sequence {
    pub data: *mut test_msgs__srv__BasicTypes_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__srv__BasicTypes_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__srv__BasicTypes_Response__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__srv__BasicTypes_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__srv__BasicTypes_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__srv__BasicTypes_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__srv__BasicTypes_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__BasicTypes_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__srv__Empty_Request {
    pub structure_needs_at_least_one_member: u8,
}
#[test]
fn bindgen_test_layout_test_msgs__srv__Empty_Request() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__srv__Empty_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__srv__Empty_Request>(),
        1usize,
        concat!("Size of: ", stringify!(test_msgs__srv__Empty_Request))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__srv__Empty_Request>(),
        1usize,
        concat!("Alignment of ", stringify!(test_msgs__srv__Empty_Request))
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).structure_needs_at_least_one_member) as usize - ptr as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Empty_Request),
            "::",
            stringify!(structure_needs_at_least_one_member)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__srv__Empty_Request__Sequence {
    pub data: *mut test_msgs__srv__Empty_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__srv__Empty_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__srv__Empty_Request__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__srv__Empty_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__srv__Empty_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__srv__Empty_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__srv__Empty_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Empty_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Empty_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Empty_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__srv__Empty_Response {
    pub structure_needs_at_least_one_member: u8,
}
#[test]
fn bindgen_test_layout_test_msgs__srv__Empty_Response() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__srv__Empty_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__srv__Empty_Response>(),
        1usize,
        concat!("Size of: ", stringify!(test_msgs__srv__Empty_Response))
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__srv__Empty_Response>(),
        1usize,
        concat!("Alignment of ", stringify!(test_msgs__srv__Empty_Response))
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).structure_needs_at_least_one_member) as usize - ptr as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Empty_Response),
            "::",
            stringify!(structure_needs_at_least_one_member)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct test_msgs__srv__Empty_Response__Sequence {
    pub data: *mut test_msgs__srv__Empty_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_test_msgs__srv__Empty_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<test_msgs__srv__Empty_Response__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<test_msgs__srv__Empty_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(test_msgs__srv__Empty_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<test_msgs__srv__Empty_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(test_msgs__srv__Empty_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Empty_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Empty_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(test_msgs__srv__Empty_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct tf2_msgs__action__LookupTransform_Goal {
    pub target_frame: rosidl_runtime_c__String,
    pub source_frame: rosidl_runtime_c__String,
    pub source_time: builtin_interfaces__msg__Time,
    pub timeout: builtin_interfaces__msg__Duration,
    pub target_time: builtin_interfaces__msg__Time,
    pub fixed_frame: rosidl_runtime_c__String,
    pub advanced: bool,
}
#[test]
fn bindgen_test_layout_tf2_msgs__action__LookupTransform_Goal() {
    const UNINIT: ::std::mem::MaybeUninit<tf2_msgs__action__LookupTransform_Goal> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tf2_msgs__action__LookupTransform_Goal>(),
        104usize,
        concat!(
            "Size of: ",
            stringify!(tf2_msgs__action__LookupTransform_Goal)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<tf2_msgs__action__LookupTransform_Goal>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(tf2_msgs__action__LookupTransform_Goal)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).target_frame) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_Goal),
            "::",
            stringify!(target_frame)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).source_frame) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_Goal),
            "::",
            stringify!(source_frame)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).source_time) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_Goal),
            "::",
            stringify!(source_time)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).timeout) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_Goal),
            "::",
            stringify!(timeout)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).target_time) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_Goal),
            "::",
            stringify!(target_time)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fixed_frame) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_Goal),
            "::",
            stringify!(fixed_frame)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).advanced) as usize - ptr as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_Goal),
            "::",
            stringify!(advanced)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct tf2_msgs__action__LookupTransform_Goal__Sequence {
    pub data: *mut tf2_msgs__action__LookupTransform_Goal,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_tf2_msgs__action__LookupTransform_Goal__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<tf2_msgs__action__LookupTransform_Goal__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tf2_msgs__action__LookupTransform_Goal__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(tf2_msgs__action__LookupTransform_Goal__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<tf2_msgs__action__LookupTransform_Goal__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(tf2_msgs__action__LookupTransform_Goal__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_Goal__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_Goal__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_Goal__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const tf2_msgs__msg__TF2Error__NO_ERROR: _bindgen_ty_227 =
    _bindgen_ty_227::tf2_msgs__msg__TF2Error__NO_ERROR;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_227 {
    tf2_msgs__msg__TF2Error__NO_ERROR = 0,
}
pub const tf2_msgs__msg__TF2Error__LOOKUP_ERROR: _bindgen_ty_228 =
    _bindgen_ty_228::tf2_msgs__msg__TF2Error__LOOKUP_ERROR;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_228 {
    tf2_msgs__msg__TF2Error__LOOKUP_ERROR = 1,
}
pub const tf2_msgs__msg__TF2Error__CONNECTIVITY_ERROR: _bindgen_ty_229 =
    _bindgen_ty_229::tf2_msgs__msg__TF2Error__CONNECTIVITY_ERROR;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_229 {
    tf2_msgs__msg__TF2Error__CONNECTIVITY_ERROR = 2,
}
pub const tf2_msgs__msg__TF2Error__EXTRAPOLATION_ERROR: _bindgen_ty_230 =
    _bindgen_ty_230::tf2_msgs__msg__TF2Error__EXTRAPOLATION_ERROR;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_230 {
    tf2_msgs__msg__TF2Error__EXTRAPOLATION_ERROR = 3,
}
pub const tf2_msgs__msg__TF2Error__INVALID_ARGUMENT_ERROR: _bindgen_ty_231 =
    _bindgen_ty_231::tf2_msgs__msg__TF2Error__INVALID_ARGUMENT_ERROR;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_231 {
    tf2_msgs__msg__TF2Error__INVALID_ARGUMENT_ERROR = 4,
}
pub const tf2_msgs__msg__TF2Error__TIMEOUT_ERROR: _bindgen_ty_232 =
    _bindgen_ty_232::tf2_msgs__msg__TF2Error__TIMEOUT_ERROR;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_232 {
    tf2_msgs__msg__TF2Error__TIMEOUT_ERROR = 5,
}
pub const tf2_msgs__msg__TF2Error__TRANSFORM_ERROR: _bindgen_ty_233 =
    _bindgen_ty_233::tf2_msgs__msg__TF2Error__TRANSFORM_ERROR;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_233 {
    tf2_msgs__msg__TF2Error__TRANSFORM_ERROR = 6,
}
#[repr(C)]
pub struct tf2_msgs__msg__TF2Error {
    pub error: u8,
    pub error_string: rosidl_runtime_c__String,
}
#[test]
fn bindgen_test_layout_tf2_msgs__msg__TF2Error() {
    const UNINIT: ::std::mem::MaybeUninit<tf2_msgs__msg__TF2Error> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tf2_msgs__msg__TF2Error>(),
        32usize,
        concat!("Size of: ", stringify!(tf2_msgs__msg__TF2Error))
    );
    assert_eq!(
        ::std::mem::align_of::<tf2_msgs__msg__TF2Error>(),
        8usize,
        concat!("Alignment of ", stringify!(tf2_msgs__msg__TF2Error))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).error) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__msg__TF2Error),
            "::",
            stringify!(error)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).error_string) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__msg__TF2Error),
            "::",
            stringify!(error_string)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct tf2_msgs__msg__TF2Error__Sequence {
    pub data: *mut tf2_msgs__msg__TF2Error,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_tf2_msgs__msg__TF2Error__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<tf2_msgs__msg__TF2Error__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tf2_msgs__msg__TF2Error__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(tf2_msgs__msg__TF2Error__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<tf2_msgs__msg__TF2Error__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(tf2_msgs__msg__TF2Error__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__msg__TF2Error__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__msg__TF2Error__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__msg__TF2Error__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct tf2_msgs__action__LookupTransform_Result {
    pub transform: geometry_msgs__msg__TransformStamped,
    pub error: tf2_msgs__msg__TF2Error,
}
#[test]
fn bindgen_test_layout_tf2_msgs__action__LookupTransform_Result() {
    const UNINIT: ::std::mem::MaybeUninit<tf2_msgs__action__LookupTransform_Result> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tf2_msgs__action__LookupTransform_Result>(),
        144usize,
        concat!(
            "Size of: ",
            stringify!(tf2_msgs__action__LookupTransform_Result)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<tf2_msgs__action__LookupTransform_Result>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(tf2_msgs__action__LookupTransform_Result)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).transform) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_Result),
            "::",
            stringify!(transform)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).error) as usize - ptr as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_Result),
            "::",
            stringify!(error)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct tf2_msgs__action__LookupTransform_Result__Sequence {
    pub data: *mut tf2_msgs__action__LookupTransform_Result,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_tf2_msgs__action__LookupTransform_Result__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<tf2_msgs__action__LookupTransform_Result__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tf2_msgs__action__LookupTransform_Result__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(tf2_msgs__action__LookupTransform_Result__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<tf2_msgs__action__LookupTransform_Result__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(tf2_msgs__action__LookupTransform_Result__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_Result__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_Result__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_Result__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct tf2_msgs__action__LookupTransform_Feedback {
    pub structure_needs_at_least_one_member: u8,
}
#[test]
fn bindgen_test_layout_tf2_msgs__action__LookupTransform_Feedback() {
    const UNINIT: ::std::mem::MaybeUninit<tf2_msgs__action__LookupTransform_Feedback> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tf2_msgs__action__LookupTransform_Feedback>(),
        1usize,
        concat!(
            "Size of: ",
            stringify!(tf2_msgs__action__LookupTransform_Feedback)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<tf2_msgs__action__LookupTransform_Feedback>(),
        1usize,
        concat!(
            "Alignment of ",
            stringify!(tf2_msgs__action__LookupTransform_Feedback)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).structure_needs_at_least_one_member) as usize - ptr as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_Feedback),
            "::",
            stringify!(structure_needs_at_least_one_member)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct tf2_msgs__action__LookupTransform_Feedback__Sequence {
    pub data: *mut tf2_msgs__action__LookupTransform_Feedback,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_tf2_msgs__action__LookupTransform_Feedback__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<tf2_msgs__action__LookupTransform_Feedback__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tf2_msgs__action__LookupTransform_Feedback__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(tf2_msgs__action__LookupTransform_Feedback__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<tf2_msgs__action__LookupTransform_Feedback__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(tf2_msgs__action__LookupTransform_Feedback__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_Feedback__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_Feedback__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_Feedback__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct tf2_msgs__action__LookupTransform_SendGoal_Request {
    pub goal_id: unique_identifier_msgs__msg__UUID,
    pub goal: tf2_msgs__action__LookupTransform_Goal,
}
#[test]
fn bindgen_test_layout_tf2_msgs__action__LookupTransform_SendGoal_Request() {
    const UNINIT: ::std::mem::MaybeUninit<tf2_msgs__action__LookupTransform_SendGoal_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tf2_msgs__action__LookupTransform_SendGoal_Request>(),
        120usize,
        concat!(
            "Size of: ",
            stringify!(tf2_msgs__action__LookupTransform_SendGoal_Request)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<tf2_msgs__action__LookupTransform_SendGoal_Request>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(tf2_msgs__action__LookupTransform_SendGoal_Request)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).goal_id) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_SendGoal_Request),
            "::",
            stringify!(goal_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).goal) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_SendGoal_Request),
            "::",
            stringify!(goal)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct tf2_msgs__action__LookupTransform_SendGoal_Request__Sequence {
    pub data: *mut tf2_msgs__action__LookupTransform_SendGoal_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_tf2_msgs__action__LookupTransform_SendGoal_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        tf2_msgs__action__LookupTransform_SendGoal_Request__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tf2_msgs__action__LookupTransform_SendGoal_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(tf2_msgs__action__LookupTransform_SendGoal_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<tf2_msgs__action__LookupTransform_SendGoal_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(tf2_msgs__action__LookupTransform_SendGoal_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_SendGoal_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_SendGoal_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_SendGoal_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct tf2_msgs__action__LookupTransform_SendGoal_Response {
    pub accepted: bool,
    pub stamp: builtin_interfaces__msg__Time,
}
#[test]
fn bindgen_test_layout_tf2_msgs__action__LookupTransform_SendGoal_Response() {
    const UNINIT: ::std::mem::MaybeUninit<tf2_msgs__action__LookupTransform_SendGoal_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tf2_msgs__action__LookupTransform_SendGoal_Response>(),
        12usize,
        concat!(
            "Size of: ",
            stringify!(tf2_msgs__action__LookupTransform_SendGoal_Response)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<tf2_msgs__action__LookupTransform_SendGoal_Response>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(tf2_msgs__action__LookupTransform_SendGoal_Response)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).accepted) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_SendGoal_Response),
            "::",
            stringify!(accepted)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).stamp) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_SendGoal_Response),
            "::",
            stringify!(stamp)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct tf2_msgs__action__LookupTransform_SendGoal_Response__Sequence {
    pub data: *mut tf2_msgs__action__LookupTransform_SendGoal_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_tf2_msgs__action__LookupTransform_SendGoal_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        tf2_msgs__action__LookupTransform_SendGoal_Response__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tf2_msgs__action__LookupTransform_SendGoal_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(tf2_msgs__action__LookupTransform_SendGoal_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<tf2_msgs__action__LookupTransform_SendGoal_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(tf2_msgs__action__LookupTransform_SendGoal_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_SendGoal_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_SendGoal_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_SendGoal_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct tf2_msgs__action__LookupTransform_GetResult_Request {
    pub goal_id: unique_identifier_msgs__msg__UUID,
}
#[test]
fn bindgen_test_layout_tf2_msgs__action__LookupTransform_GetResult_Request() {
    const UNINIT: ::std::mem::MaybeUninit<tf2_msgs__action__LookupTransform_GetResult_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tf2_msgs__action__LookupTransform_GetResult_Request>(),
        16usize,
        concat!(
            "Size of: ",
            stringify!(tf2_msgs__action__LookupTransform_GetResult_Request)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<tf2_msgs__action__LookupTransform_GetResult_Request>(),
        1usize,
        concat!(
            "Alignment of ",
            stringify!(tf2_msgs__action__LookupTransform_GetResult_Request)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).goal_id) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_GetResult_Request),
            "::",
            stringify!(goal_id)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct tf2_msgs__action__LookupTransform_GetResult_Request__Sequence {
    pub data: *mut tf2_msgs__action__LookupTransform_GetResult_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_tf2_msgs__action__LookupTransform_GetResult_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        tf2_msgs__action__LookupTransform_GetResult_Request__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tf2_msgs__action__LookupTransform_GetResult_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(tf2_msgs__action__LookupTransform_GetResult_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<tf2_msgs__action__LookupTransform_GetResult_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(tf2_msgs__action__LookupTransform_GetResult_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_GetResult_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_GetResult_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_GetResult_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct tf2_msgs__action__LookupTransform_GetResult_Response {
    pub status: i8,
    pub result: tf2_msgs__action__LookupTransform_Result,
}
#[test]
fn bindgen_test_layout_tf2_msgs__action__LookupTransform_GetResult_Response() {
    const UNINIT: ::std::mem::MaybeUninit<tf2_msgs__action__LookupTransform_GetResult_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tf2_msgs__action__LookupTransform_GetResult_Response>(),
        152usize,
        concat!(
            "Size of: ",
            stringify!(tf2_msgs__action__LookupTransform_GetResult_Response)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<tf2_msgs__action__LookupTransform_GetResult_Response>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(tf2_msgs__action__LookupTransform_GetResult_Response)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).status) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_GetResult_Response),
            "::",
            stringify!(status)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).result) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_GetResult_Response),
            "::",
            stringify!(result)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct tf2_msgs__action__LookupTransform_GetResult_Response__Sequence {
    pub data: *mut tf2_msgs__action__LookupTransform_GetResult_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_tf2_msgs__action__LookupTransform_GetResult_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        tf2_msgs__action__LookupTransform_GetResult_Response__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tf2_msgs__action__LookupTransform_GetResult_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(tf2_msgs__action__LookupTransform_GetResult_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<tf2_msgs__action__LookupTransform_GetResult_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(tf2_msgs__action__LookupTransform_GetResult_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_GetResult_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_GetResult_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_GetResult_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct tf2_msgs__action__LookupTransform_FeedbackMessage {
    pub goal_id: unique_identifier_msgs__msg__UUID,
    pub feedback: tf2_msgs__action__LookupTransform_Feedback,
}
#[test]
fn bindgen_test_layout_tf2_msgs__action__LookupTransform_FeedbackMessage() {
    const UNINIT: ::std::mem::MaybeUninit<tf2_msgs__action__LookupTransform_FeedbackMessage> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tf2_msgs__action__LookupTransform_FeedbackMessage>(),
        17usize,
        concat!(
            "Size of: ",
            stringify!(tf2_msgs__action__LookupTransform_FeedbackMessage)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<tf2_msgs__action__LookupTransform_FeedbackMessage>(),
        1usize,
        concat!(
            "Alignment of ",
            stringify!(tf2_msgs__action__LookupTransform_FeedbackMessage)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).goal_id) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_FeedbackMessage),
            "::",
            stringify!(goal_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).feedback) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_FeedbackMessage),
            "::",
            stringify!(feedback)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct tf2_msgs__action__LookupTransform_FeedbackMessage__Sequence {
    pub data: *mut tf2_msgs__action__LookupTransform_FeedbackMessage,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_tf2_msgs__action__LookupTransform_FeedbackMessage__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        tf2_msgs__action__LookupTransform_FeedbackMessage__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tf2_msgs__action__LookupTransform_FeedbackMessage__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(tf2_msgs__action__LookupTransform_FeedbackMessage__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<tf2_msgs__action__LookupTransform_FeedbackMessage__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(tf2_msgs__action__LookupTransform_FeedbackMessage__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_FeedbackMessage__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_FeedbackMessage__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__action__LookupTransform_FeedbackMessage__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct tf2_msgs__msg__TFMessage {
    pub transforms: geometry_msgs__msg__TransformStamped__Sequence,
}
#[test]
fn bindgen_test_layout_tf2_msgs__msg__TFMessage() {
    const UNINIT: ::std::mem::MaybeUninit<tf2_msgs__msg__TFMessage> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tf2_msgs__msg__TFMessage>(),
        24usize,
        concat!("Size of: ", stringify!(tf2_msgs__msg__TFMessage))
    );
    assert_eq!(
        ::std::mem::align_of::<tf2_msgs__msg__TFMessage>(),
        8usize,
        concat!("Alignment of ", stringify!(tf2_msgs__msg__TFMessage))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).transforms) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__msg__TFMessage),
            "::",
            stringify!(transforms)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct tf2_msgs__msg__TFMessage__Sequence {
    pub data: *mut tf2_msgs__msg__TFMessage,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_tf2_msgs__msg__TFMessage__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<tf2_msgs__msg__TFMessage__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tf2_msgs__msg__TFMessage__Sequence>(),
        24usize,
        concat!("Size of: ", stringify!(tf2_msgs__msg__TFMessage__Sequence))
    );
    assert_eq!(
        ::std::mem::align_of::<tf2_msgs__msg__TFMessage__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(tf2_msgs__msg__TFMessage__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__msg__TFMessage__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__msg__TFMessage__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__msg__TFMessage__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct tf2_msgs__srv__FrameGraph_Request {
    pub structure_needs_at_least_one_member: u8,
}
#[test]
fn bindgen_test_layout_tf2_msgs__srv__FrameGraph_Request() {
    const UNINIT: ::std::mem::MaybeUninit<tf2_msgs__srv__FrameGraph_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tf2_msgs__srv__FrameGraph_Request>(),
        1usize,
        concat!("Size of: ", stringify!(tf2_msgs__srv__FrameGraph_Request))
    );
    assert_eq!(
        ::std::mem::align_of::<tf2_msgs__srv__FrameGraph_Request>(),
        1usize,
        concat!(
            "Alignment of ",
            stringify!(tf2_msgs__srv__FrameGraph_Request)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).structure_needs_at_least_one_member) as usize - ptr as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__srv__FrameGraph_Request),
            "::",
            stringify!(structure_needs_at_least_one_member)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct tf2_msgs__srv__FrameGraph_Request__Sequence {
    pub data: *mut tf2_msgs__srv__FrameGraph_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_tf2_msgs__srv__FrameGraph_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<tf2_msgs__srv__FrameGraph_Request__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tf2_msgs__srv__FrameGraph_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(tf2_msgs__srv__FrameGraph_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<tf2_msgs__srv__FrameGraph_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(tf2_msgs__srv__FrameGraph_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__srv__FrameGraph_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__srv__FrameGraph_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__srv__FrameGraph_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct tf2_msgs__srv__FrameGraph_Response {
    pub frame_yaml: rosidl_runtime_c__String,
}
#[test]
fn bindgen_test_layout_tf2_msgs__srv__FrameGraph_Response() {
    const UNINIT: ::std::mem::MaybeUninit<tf2_msgs__srv__FrameGraph_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tf2_msgs__srv__FrameGraph_Response>(),
        24usize,
        concat!("Size of: ", stringify!(tf2_msgs__srv__FrameGraph_Response))
    );
    assert_eq!(
        ::std::mem::align_of::<tf2_msgs__srv__FrameGraph_Response>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(tf2_msgs__srv__FrameGraph_Response)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).frame_yaml) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__srv__FrameGraph_Response),
            "::",
            stringify!(frame_yaml)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct tf2_msgs__srv__FrameGraph_Response__Sequence {
    pub data: *mut tf2_msgs__srv__FrameGraph_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_tf2_msgs__srv__FrameGraph_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<tf2_msgs__srv__FrameGraph_Response__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<tf2_msgs__srv__FrameGraph_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(tf2_msgs__srv__FrameGraph_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<tf2_msgs__srv__FrameGraph_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(tf2_msgs__srv__FrameGraph_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__srv__FrameGraph_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__srv__FrameGraph_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(tf2_msgs__srv__FrameGraph_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct trajectory_msgs__msg__JointTrajectoryPoint {
    pub positions: rosidl_runtime_c__double__Sequence,
    pub velocities: rosidl_runtime_c__double__Sequence,
    pub accelerations: rosidl_runtime_c__double__Sequence,
    pub effort: rosidl_runtime_c__double__Sequence,
    pub time_from_start: builtin_interfaces__msg__Duration,
}
#[test]
fn bindgen_test_layout_trajectory_msgs__msg__JointTrajectoryPoint() {
    const UNINIT: ::std::mem::MaybeUninit<trajectory_msgs__msg__JointTrajectoryPoint> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<trajectory_msgs__msg__JointTrajectoryPoint>(),
        104usize,
        concat!(
            "Size of: ",
            stringify!(trajectory_msgs__msg__JointTrajectoryPoint)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<trajectory_msgs__msg__JointTrajectoryPoint>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(trajectory_msgs__msg__JointTrajectoryPoint)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).positions) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__JointTrajectoryPoint),
            "::",
            stringify!(positions)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).velocities) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__JointTrajectoryPoint),
            "::",
            stringify!(velocities)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).accelerations) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__JointTrajectoryPoint),
            "::",
            stringify!(accelerations)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).effort) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__JointTrajectoryPoint),
            "::",
            stringify!(effort)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).time_from_start) as usize - ptr as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__JointTrajectoryPoint),
            "::",
            stringify!(time_from_start)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct trajectory_msgs__msg__JointTrajectoryPoint__Sequence {
    pub data: *mut trajectory_msgs__msg__JointTrajectoryPoint,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_trajectory_msgs__msg__JointTrajectoryPoint__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<trajectory_msgs__msg__JointTrajectoryPoint__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<trajectory_msgs__msg__JointTrajectoryPoint__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(trajectory_msgs__msg__JointTrajectoryPoint__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<trajectory_msgs__msg__JointTrajectoryPoint__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(trajectory_msgs__msg__JointTrajectoryPoint__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__JointTrajectoryPoint__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__JointTrajectoryPoint__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__JointTrajectoryPoint__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct trajectory_msgs__msg__JointTrajectory {
    pub header: std_msgs__msg__Header,
    pub joint_names: rosidl_runtime_c__String__Sequence,
    pub points: trajectory_msgs__msg__JointTrajectoryPoint__Sequence,
}
#[test]
fn bindgen_test_layout_trajectory_msgs__msg__JointTrajectory() {
    const UNINIT: ::std::mem::MaybeUninit<trajectory_msgs__msg__JointTrajectory> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<trajectory_msgs__msg__JointTrajectory>(),
        80usize,
        concat!(
            "Size of: ",
            stringify!(trajectory_msgs__msg__JointTrajectory)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<trajectory_msgs__msg__JointTrajectory>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(trajectory_msgs__msg__JointTrajectory)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__JointTrajectory),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).joint_names) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__JointTrajectory),
            "::",
            stringify!(joint_names)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).points) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__JointTrajectory),
            "::",
            stringify!(points)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct trajectory_msgs__msg__JointTrajectory__Sequence {
    pub data: *mut trajectory_msgs__msg__JointTrajectory,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_trajectory_msgs__msg__JointTrajectory__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<trajectory_msgs__msg__JointTrajectory__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<trajectory_msgs__msg__JointTrajectory__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(trajectory_msgs__msg__JointTrajectory__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<trajectory_msgs__msg__JointTrajectory__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(trajectory_msgs__msg__JointTrajectory__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__JointTrajectory__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__JointTrajectory__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__JointTrajectory__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct trajectory_msgs__msg__MultiDOFJointTrajectoryPoint {
    pub transforms: geometry_msgs__msg__Transform__Sequence,
    pub velocities: geometry_msgs__msg__Twist__Sequence,
    pub accelerations: geometry_msgs__msg__Twist__Sequence,
    pub time_from_start: builtin_interfaces__msg__Duration,
}
#[test]
fn bindgen_test_layout_trajectory_msgs__msg__MultiDOFJointTrajectoryPoint() {
    const UNINIT: ::std::mem::MaybeUninit<trajectory_msgs__msg__MultiDOFJointTrajectoryPoint> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<trajectory_msgs__msg__MultiDOFJointTrajectoryPoint>(),
        80usize,
        concat!(
            "Size of: ",
            stringify!(trajectory_msgs__msg__MultiDOFJointTrajectoryPoint)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<trajectory_msgs__msg__MultiDOFJointTrajectoryPoint>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(trajectory_msgs__msg__MultiDOFJointTrajectoryPoint)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).transforms) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__MultiDOFJointTrajectoryPoint),
            "::",
            stringify!(transforms)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).velocities) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__MultiDOFJointTrajectoryPoint),
            "::",
            stringify!(velocities)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).accelerations) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__MultiDOFJointTrajectoryPoint),
            "::",
            stringify!(accelerations)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).time_from_start) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__MultiDOFJointTrajectoryPoint),
            "::",
            stringify!(time_from_start)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct trajectory_msgs__msg__MultiDOFJointTrajectoryPoint__Sequence {
    pub data: *mut trajectory_msgs__msg__MultiDOFJointTrajectoryPoint,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_trajectory_msgs__msg__MultiDOFJointTrajectoryPoint__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        trajectory_msgs__msg__MultiDOFJointTrajectoryPoint__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<trajectory_msgs__msg__MultiDOFJointTrajectoryPoint__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(trajectory_msgs__msg__MultiDOFJointTrajectoryPoint__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<trajectory_msgs__msg__MultiDOFJointTrajectoryPoint__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(trajectory_msgs__msg__MultiDOFJointTrajectoryPoint__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__MultiDOFJointTrajectoryPoint__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__MultiDOFJointTrajectoryPoint__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__MultiDOFJointTrajectoryPoint__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct trajectory_msgs__msg__MultiDOFJointTrajectory {
    pub header: std_msgs__msg__Header,
    pub joint_names: rosidl_runtime_c__String__Sequence,
    pub points: trajectory_msgs__msg__MultiDOFJointTrajectoryPoint__Sequence,
}
#[test]
fn bindgen_test_layout_trajectory_msgs__msg__MultiDOFJointTrajectory() {
    const UNINIT: ::std::mem::MaybeUninit<trajectory_msgs__msg__MultiDOFJointTrajectory> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<trajectory_msgs__msg__MultiDOFJointTrajectory>(),
        80usize,
        concat!(
            "Size of: ",
            stringify!(trajectory_msgs__msg__MultiDOFJointTrajectory)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<trajectory_msgs__msg__MultiDOFJointTrajectory>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(trajectory_msgs__msg__MultiDOFJointTrajectory)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__MultiDOFJointTrajectory),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).joint_names) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__MultiDOFJointTrajectory),
            "::",
            stringify!(joint_names)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).points) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__MultiDOFJointTrajectory),
            "::",
            stringify!(points)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct trajectory_msgs__msg__MultiDOFJointTrajectory__Sequence {
    pub data: *mut trajectory_msgs__msg__MultiDOFJointTrajectory,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_trajectory_msgs__msg__MultiDOFJointTrajectory__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<trajectory_msgs__msg__MultiDOFJointTrajectory__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<trajectory_msgs__msg__MultiDOFJointTrajectory__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(trajectory_msgs__msg__MultiDOFJointTrajectory__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<trajectory_msgs__msg__MultiDOFJointTrajectory__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(trajectory_msgs__msg__MultiDOFJointTrajectory__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__MultiDOFJointTrajectory__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__MultiDOFJointTrajectory__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(trajectory_msgs__msg__MultiDOFJointTrajectory__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const visualization_msgs__msg__ImageMarker__CIRCLE: _bindgen_ty_234 =
    _bindgen_ty_234::visualization_msgs__msg__ImageMarker__CIRCLE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_234 {
    visualization_msgs__msg__ImageMarker__CIRCLE = 0,
}
pub const visualization_msgs__msg__ImageMarker__LINE_STRIP: _bindgen_ty_235 =
    _bindgen_ty_235::visualization_msgs__msg__ImageMarker__LINE_STRIP;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_235 {
    visualization_msgs__msg__ImageMarker__LINE_STRIP = 1,
}
pub const visualization_msgs__msg__ImageMarker__LINE_LIST: _bindgen_ty_236 =
    _bindgen_ty_236::visualization_msgs__msg__ImageMarker__LINE_LIST;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_236 {
    visualization_msgs__msg__ImageMarker__LINE_LIST = 2,
}
pub const visualization_msgs__msg__ImageMarker__POLYGON: _bindgen_ty_237 =
    _bindgen_ty_237::visualization_msgs__msg__ImageMarker__POLYGON;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_237 {
    visualization_msgs__msg__ImageMarker__POLYGON = 3,
}
pub const visualization_msgs__msg__ImageMarker__POINTS: _bindgen_ty_238 =
    _bindgen_ty_238::visualization_msgs__msg__ImageMarker__POINTS;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_238 {
    visualization_msgs__msg__ImageMarker__POINTS = 4,
}
pub const visualization_msgs__msg__ImageMarker__ADD: _bindgen_ty_239 =
    _bindgen_ty_239::visualization_msgs__msg__ImageMarker__ADD;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_239 {
    visualization_msgs__msg__ImageMarker__ADD = 0,
}
pub const visualization_msgs__msg__ImageMarker__REMOVE: _bindgen_ty_240 =
    _bindgen_ty_240::visualization_msgs__msg__ImageMarker__REMOVE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_240 {
    visualization_msgs__msg__ImageMarker__REMOVE = 1,
}
#[repr(C)]
pub struct visualization_msgs__msg__ImageMarker {
    pub header: std_msgs__msg__Header,
    pub ns: rosidl_runtime_c__String,
    pub id: i32,
    pub type_: i32,
    pub action: i32,
    pub position: geometry_msgs__msg__Point,
    pub scale: f32,
    pub outline_color: std_msgs__msg__ColorRGBA,
    pub filled: u8,
    pub fill_color: std_msgs__msg__ColorRGBA,
    pub lifetime: builtin_interfaces__msg__Duration,
    pub points: geometry_msgs__msg__Point__Sequence,
    pub outline_colors: std_msgs__msg__ColorRGBA__Sequence,
}
#[test]
fn bindgen_test_layout_visualization_msgs__msg__ImageMarker() {
    const UNINIT: ::std::mem::MaybeUninit<visualization_msgs__msg__ImageMarker> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__msg__ImageMarker>(),
        192usize,
        concat!(
            "Size of: ",
            stringify!(visualization_msgs__msg__ImageMarker)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__msg__ImageMarker>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__msg__ImageMarker)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__ImageMarker),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ns) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__ImageMarker),
            "::",
            stringify!(ns)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__ImageMarker),
            "::",
            stringify!(id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__ImageMarker),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).action) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__ImageMarker),
            "::",
            stringify!(action)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).position) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__ImageMarker),
            "::",
            stringify!(position)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scale) as usize - ptr as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__ImageMarker),
            "::",
            stringify!(scale)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).outline_color) as usize - ptr as usize },
        100usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__ImageMarker),
            "::",
            stringify!(outline_color)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).filled) as usize - ptr as usize },
        116usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__ImageMarker),
            "::",
            stringify!(filled)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).fill_color) as usize - ptr as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__ImageMarker),
            "::",
            stringify!(fill_color)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).lifetime) as usize - ptr as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__ImageMarker),
            "::",
            stringify!(lifetime)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).points) as usize - ptr as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__ImageMarker),
            "::",
            stringify!(points)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).outline_colors) as usize - ptr as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__ImageMarker),
            "::",
            stringify!(outline_colors)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct visualization_msgs__msg__ImageMarker__Sequence {
    pub data: *mut visualization_msgs__msg__ImageMarker,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_visualization_msgs__msg__ImageMarker__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<visualization_msgs__msg__ImageMarker__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__msg__ImageMarker__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(visualization_msgs__msg__ImageMarker__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__msg__ImageMarker__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__msg__ImageMarker__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__ImageMarker__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__ImageMarker__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__ImageMarker__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const visualization_msgs__msg__MenuEntry__FEEDBACK: _bindgen_ty_241 =
    _bindgen_ty_241::visualization_msgs__msg__MenuEntry__FEEDBACK;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_241 {
    visualization_msgs__msg__MenuEntry__FEEDBACK = 0,
}
pub const visualization_msgs__msg__MenuEntry__ROSRUN: _bindgen_ty_242 =
    _bindgen_ty_242::visualization_msgs__msg__MenuEntry__ROSRUN;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_242 {
    visualization_msgs__msg__MenuEntry__ROSRUN = 1,
}
pub const visualization_msgs__msg__MenuEntry__ROSLAUNCH: _bindgen_ty_243 =
    _bindgen_ty_243::visualization_msgs__msg__MenuEntry__ROSLAUNCH;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_243 {
    visualization_msgs__msg__MenuEntry__ROSLAUNCH = 2,
}
#[repr(C)]
pub struct visualization_msgs__msg__MenuEntry {
    pub id: u32,
    pub parent_id: u32,
    pub title: rosidl_runtime_c__String,
    pub command: rosidl_runtime_c__String,
    pub command_type: u8,
}
#[test]
fn bindgen_test_layout_visualization_msgs__msg__MenuEntry() {
    const UNINIT: ::std::mem::MaybeUninit<visualization_msgs__msg__MenuEntry> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__msg__MenuEntry>(),
        64usize,
        concat!("Size of: ", stringify!(visualization_msgs__msg__MenuEntry))
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__msg__MenuEntry>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__msg__MenuEntry)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__MenuEntry),
            "::",
            stringify!(id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).parent_id) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__MenuEntry),
            "::",
            stringify!(parent_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).title) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__MenuEntry),
            "::",
            stringify!(title)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).command) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__MenuEntry),
            "::",
            stringify!(command)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).command_type) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__MenuEntry),
            "::",
            stringify!(command_type)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct visualization_msgs__msg__MenuEntry__Sequence {
    pub data: *mut visualization_msgs__msg__MenuEntry,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_visualization_msgs__msg__MenuEntry__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<visualization_msgs__msg__MenuEntry__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__msg__MenuEntry__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(visualization_msgs__msg__MenuEntry__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__msg__MenuEntry__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__msg__MenuEntry__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__MenuEntry__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__MenuEntry__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__MenuEntry__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const visualization_msgs__msg__InteractiveMarkerControl__INHERIT: _bindgen_ty_244 =
    _bindgen_ty_244::visualization_msgs__msg__InteractiveMarkerControl__INHERIT;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_244 {
    visualization_msgs__msg__InteractiveMarkerControl__INHERIT = 0,
}
pub const visualization_msgs__msg__InteractiveMarkerControl__FIXED: _bindgen_ty_245 =
    _bindgen_ty_245::visualization_msgs__msg__InteractiveMarkerControl__FIXED;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_245 {
    visualization_msgs__msg__InteractiveMarkerControl__FIXED = 1,
}
pub const visualization_msgs__msg__InteractiveMarkerControl__VIEW_FACING: _bindgen_ty_246 =
    _bindgen_ty_246::visualization_msgs__msg__InteractiveMarkerControl__VIEW_FACING;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_246 {
    visualization_msgs__msg__InteractiveMarkerControl__VIEW_FACING = 2,
}
pub const visualization_msgs__msg__InteractiveMarkerControl__NONE: _bindgen_ty_247 =
    _bindgen_ty_247::visualization_msgs__msg__InteractiveMarkerControl__NONE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_247 {
    visualization_msgs__msg__InteractiveMarkerControl__NONE = 0,
}
pub const visualization_msgs__msg__InteractiveMarkerControl__MENU: _bindgen_ty_248 =
    _bindgen_ty_248::visualization_msgs__msg__InteractiveMarkerControl__MENU;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_248 {
    visualization_msgs__msg__InteractiveMarkerControl__MENU = 1,
}
pub const visualization_msgs__msg__InteractiveMarkerControl__BUTTON: _bindgen_ty_249 =
    _bindgen_ty_249::visualization_msgs__msg__InteractiveMarkerControl__BUTTON;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_249 {
    visualization_msgs__msg__InteractiveMarkerControl__BUTTON = 2,
}
pub const visualization_msgs__msg__InteractiveMarkerControl__MOVE_AXIS: _bindgen_ty_250 =
    _bindgen_ty_250::visualization_msgs__msg__InteractiveMarkerControl__MOVE_AXIS;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_250 {
    visualization_msgs__msg__InteractiveMarkerControl__MOVE_AXIS = 3,
}
pub const visualization_msgs__msg__InteractiveMarkerControl__MOVE_PLANE: _bindgen_ty_251 =
    _bindgen_ty_251::visualization_msgs__msg__InteractiveMarkerControl__MOVE_PLANE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_251 {
    visualization_msgs__msg__InteractiveMarkerControl__MOVE_PLANE = 4,
}
pub const visualization_msgs__msg__InteractiveMarkerControl__ROTATE_AXIS: _bindgen_ty_252 =
    _bindgen_ty_252::visualization_msgs__msg__InteractiveMarkerControl__ROTATE_AXIS;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_252 {
    visualization_msgs__msg__InteractiveMarkerControl__ROTATE_AXIS = 5,
}
pub const visualization_msgs__msg__InteractiveMarkerControl__MOVE_ROTATE: _bindgen_ty_253 =
    _bindgen_ty_253::visualization_msgs__msg__InteractiveMarkerControl__MOVE_ROTATE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_253 {
    visualization_msgs__msg__InteractiveMarkerControl__MOVE_ROTATE = 6,
}
pub const visualization_msgs__msg__InteractiveMarkerControl__MOVE_3D: _bindgen_ty_254 =
    _bindgen_ty_254::visualization_msgs__msg__InteractiveMarkerControl__MOVE_3D;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_254 {
    visualization_msgs__msg__InteractiveMarkerControl__MOVE_3D = 7,
}
pub const visualization_msgs__msg__InteractiveMarkerControl__ROTATE_3D: _bindgen_ty_255 =
    _bindgen_ty_255::visualization_msgs__msg__InteractiveMarkerControl__ROTATE_3D;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_255 {
    visualization_msgs__msg__InteractiveMarkerControl__ROTATE_3D = 8,
}
pub const visualization_msgs__msg__InteractiveMarkerControl__MOVE_ROTATE_3D: _bindgen_ty_256 =
    _bindgen_ty_256::visualization_msgs__msg__InteractiveMarkerControl__MOVE_ROTATE_3D;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_256 {
    visualization_msgs__msg__InteractiveMarkerControl__MOVE_ROTATE_3D = 9,
}
pub const visualization_msgs__msg__Marker__ARROW: _bindgen_ty_257 =
    _bindgen_ty_257::visualization_msgs__msg__Marker__ARROW;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_257 {
    visualization_msgs__msg__Marker__ARROW = 0,
}
pub const visualization_msgs__msg__Marker__CUBE: _bindgen_ty_258 =
    _bindgen_ty_258::visualization_msgs__msg__Marker__CUBE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_258 {
    visualization_msgs__msg__Marker__CUBE = 1,
}
pub const visualization_msgs__msg__Marker__SPHERE: _bindgen_ty_259 =
    _bindgen_ty_259::visualization_msgs__msg__Marker__SPHERE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_259 {
    visualization_msgs__msg__Marker__SPHERE = 2,
}
pub const visualization_msgs__msg__Marker__CYLINDER: _bindgen_ty_260 =
    _bindgen_ty_260::visualization_msgs__msg__Marker__CYLINDER;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_260 {
    visualization_msgs__msg__Marker__CYLINDER = 3,
}
pub const visualization_msgs__msg__Marker__LINE_STRIP: _bindgen_ty_261 =
    _bindgen_ty_261::visualization_msgs__msg__Marker__LINE_STRIP;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_261 {
    visualization_msgs__msg__Marker__LINE_STRIP = 4,
}
pub const visualization_msgs__msg__Marker__LINE_LIST: _bindgen_ty_262 =
    _bindgen_ty_262::visualization_msgs__msg__Marker__LINE_LIST;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_262 {
    visualization_msgs__msg__Marker__LINE_LIST = 5,
}
pub const visualization_msgs__msg__Marker__CUBE_LIST: _bindgen_ty_263 =
    _bindgen_ty_263::visualization_msgs__msg__Marker__CUBE_LIST;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_263 {
    visualization_msgs__msg__Marker__CUBE_LIST = 6,
}
pub const visualization_msgs__msg__Marker__SPHERE_LIST: _bindgen_ty_264 =
    _bindgen_ty_264::visualization_msgs__msg__Marker__SPHERE_LIST;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_264 {
    visualization_msgs__msg__Marker__SPHERE_LIST = 7,
}
pub const visualization_msgs__msg__Marker__POINTS: _bindgen_ty_265 =
    _bindgen_ty_265::visualization_msgs__msg__Marker__POINTS;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_265 {
    visualization_msgs__msg__Marker__POINTS = 8,
}
pub const visualization_msgs__msg__Marker__TEXT_VIEW_FACING: _bindgen_ty_266 =
    _bindgen_ty_266::visualization_msgs__msg__Marker__TEXT_VIEW_FACING;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_266 {
    visualization_msgs__msg__Marker__TEXT_VIEW_FACING = 9,
}
pub const visualization_msgs__msg__Marker__MESH_RESOURCE: _bindgen_ty_267 =
    _bindgen_ty_267::visualization_msgs__msg__Marker__MESH_RESOURCE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_267 {
    visualization_msgs__msg__Marker__MESH_RESOURCE = 10,
}
pub const visualization_msgs__msg__Marker__TRIANGLE_LIST: _bindgen_ty_268 =
    _bindgen_ty_268::visualization_msgs__msg__Marker__TRIANGLE_LIST;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_268 {
    visualization_msgs__msg__Marker__TRIANGLE_LIST = 11,
}
pub const visualization_msgs__msg__Marker__ADD: _bindgen_ty_269 =
    _bindgen_ty_269::visualization_msgs__msg__Marker__ADD;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_269 {
    visualization_msgs__msg__Marker__ADD = 0,
}
pub const visualization_msgs__msg__Marker__MODIFY: _bindgen_ty_270 =
    _bindgen_ty_270::visualization_msgs__msg__Marker__MODIFY;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_270 {
    visualization_msgs__msg__Marker__MODIFY = 0,
}
pub const visualization_msgs__msg__Marker__DELETE: _bindgen_ty_271 =
    _bindgen_ty_271::visualization_msgs__msg__Marker__DELETE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_271 {
    visualization_msgs__msg__Marker__DELETE = 2,
}
pub const visualization_msgs__msg__Marker__DELETEALL: _bindgen_ty_272 =
    _bindgen_ty_272::visualization_msgs__msg__Marker__DELETEALL;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_272 {
    visualization_msgs__msg__Marker__DELETEALL = 3,
}
#[repr(C)]
#[derive(Debug)]
pub struct visualization_msgs__msg__UVCoordinate {
    pub u: f32,
    pub v: f32,
}
#[test]
fn bindgen_test_layout_visualization_msgs__msg__UVCoordinate() {
    const UNINIT: ::std::mem::MaybeUninit<visualization_msgs__msg__UVCoordinate> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__msg__UVCoordinate>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(visualization_msgs__msg__UVCoordinate)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__msg__UVCoordinate>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__msg__UVCoordinate)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__UVCoordinate),
            "::",
            stringify!(u)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).v) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__UVCoordinate),
            "::",
            stringify!(v)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct visualization_msgs__msg__UVCoordinate__Sequence {
    pub data: *mut visualization_msgs__msg__UVCoordinate,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_visualization_msgs__msg__UVCoordinate__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<visualization_msgs__msg__UVCoordinate__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__msg__UVCoordinate__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(visualization_msgs__msg__UVCoordinate__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__msg__UVCoordinate__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__msg__UVCoordinate__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__UVCoordinate__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__UVCoordinate__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__UVCoordinate__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct visualization_msgs__msg__MeshFile {
    pub filename: rosidl_runtime_c__String,
    pub data: rosidl_runtime_c__uint8__Sequence,
}
#[test]
fn bindgen_test_layout_visualization_msgs__msg__MeshFile() {
    const UNINIT: ::std::mem::MaybeUninit<visualization_msgs__msg__MeshFile> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__msg__MeshFile>(),
        48usize,
        concat!("Size of: ", stringify!(visualization_msgs__msg__MeshFile))
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__msg__MeshFile>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__msg__MeshFile)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).filename) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__MeshFile),
            "::",
            stringify!(filename)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__MeshFile),
            "::",
            stringify!(data)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct visualization_msgs__msg__MeshFile__Sequence {
    pub data: *mut visualization_msgs__msg__MeshFile,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_visualization_msgs__msg__MeshFile__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<visualization_msgs__msg__MeshFile__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__msg__MeshFile__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(visualization_msgs__msg__MeshFile__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__msg__MeshFile__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__msg__MeshFile__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__MeshFile__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__MeshFile__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__MeshFile__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct visualization_msgs__msg__Marker {
    pub header: std_msgs__msg__Header,
    pub ns: rosidl_runtime_c__String,
    pub id: i32,
    pub type_: i32,
    pub action: i32,
    pub pose: geometry_msgs__msg__Pose,
    pub scale: geometry_msgs__msg__Vector3,
    pub color: std_msgs__msg__ColorRGBA,
    pub lifetime: builtin_interfaces__msg__Duration,
    pub frame_locked: bool,
    pub points: geometry_msgs__msg__Point__Sequence,
    pub colors: std_msgs__msg__ColorRGBA__Sequence,
    pub texture_resource: rosidl_runtime_c__String,
    pub texture: sensor_msgs__msg__CompressedImage,
    pub uv_coordinates: visualization_msgs__msg__UVCoordinate__Sequence,
    pub text: rosidl_runtime_c__String,
    pub mesh_resource: rosidl_runtime_c__String,
    pub mesh_file: visualization_msgs__msg__MeshFile,
    pub mesh_use_embedded_materials: bool,
}
#[test]
fn bindgen_test_layout_visualization_msgs__msg__Marker() {
    const UNINIT: ::std::mem::MaybeUninit<visualization_msgs__msg__Marker> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__msg__Marker>(),
        464usize,
        concat!("Size of: ", stringify!(visualization_msgs__msg__Marker))
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__msg__Marker>(),
        8usize,
        concat!("Alignment of ", stringify!(visualization_msgs__msg__Marker))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__Marker),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ns) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__Marker),
            "::",
            stringify!(ns)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__Marker),
            "::",
            stringify!(id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__Marker),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).action) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__Marker),
            "::",
            stringify!(action)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pose) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__Marker),
            "::",
            stringify!(pose)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scale) as usize - ptr as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__Marker),
            "::",
            stringify!(scale)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).color) as usize - ptr as usize },
        152usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__Marker),
            "::",
            stringify!(color)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).lifetime) as usize - ptr as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__Marker),
            "::",
            stringify!(lifetime)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).frame_locked) as usize - ptr as usize },
        176usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__Marker),
            "::",
            stringify!(frame_locked)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).points) as usize - ptr as usize },
        184usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__Marker),
            "::",
            stringify!(points)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).colors) as usize - ptr as usize },
        208usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__Marker),
            "::",
            stringify!(colors)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).texture_resource) as usize - ptr as usize },
        232usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__Marker),
            "::",
            stringify!(texture_resource)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).texture) as usize - ptr as usize },
        256usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__Marker),
            "::",
            stringify!(texture)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).uv_coordinates) as usize - ptr as usize },
        336usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__Marker),
            "::",
            stringify!(uv_coordinates)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).text) as usize - ptr as usize },
        360usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__Marker),
            "::",
            stringify!(text)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mesh_resource) as usize - ptr as usize },
        384usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__Marker),
            "::",
            stringify!(mesh_resource)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mesh_file) as usize - ptr as usize },
        408usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__Marker),
            "::",
            stringify!(mesh_file)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mesh_use_embedded_materials) as usize - ptr as usize },
        456usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__Marker),
            "::",
            stringify!(mesh_use_embedded_materials)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct visualization_msgs__msg__Marker__Sequence {
    pub data: *mut visualization_msgs__msg__Marker,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_visualization_msgs__msg__Marker__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<visualization_msgs__msg__Marker__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__msg__Marker__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(visualization_msgs__msg__Marker__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__msg__Marker__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__msg__Marker__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__Marker__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__Marker__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__Marker__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct visualization_msgs__msg__InteractiveMarkerControl {
    pub name: rosidl_runtime_c__String,
    pub orientation: geometry_msgs__msg__Quaternion,
    pub orientation_mode: u8,
    pub interaction_mode: u8,
    pub always_visible: bool,
    pub markers: visualization_msgs__msg__Marker__Sequence,
    pub independent_marker_orientation: bool,
    pub description: rosidl_runtime_c__String,
}
#[test]
fn bindgen_test_layout_visualization_msgs__msg__InteractiveMarkerControl() {
    const UNINIT: ::std::mem::MaybeUninit<visualization_msgs__msg__InteractiveMarkerControl> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__msg__InteractiveMarkerControl>(),
        120usize,
        concat!(
            "Size of: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerControl)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__msg__InteractiveMarkerControl>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__msg__InteractiveMarkerControl)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerControl),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).orientation) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerControl),
            "::",
            stringify!(orientation)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).orientation_mode) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerControl),
            "::",
            stringify!(orientation_mode)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).interaction_mode) as usize - ptr as usize },
        57usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerControl),
            "::",
            stringify!(interaction_mode)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).always_visible) as usize - ptr as usize },
        58usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerControl),
            "::",
            stringify!(always_visible)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).markers) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerControl),
            "::",
            stringify!(markers)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).independent_marker_orientation) as usize - ptr as usize
        },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerControl),
            "::",
            stringify!(independent_marker_orientation)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).description) as usize - ptr as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerControl),
            "::",
            stringify!(description)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct visualization_msgs__msg__InteractiveMarkerControl__Sequence {
    pub data: *mut visualization_msgs__msg__InteractiveMarkerControl,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_visualization_msgs__msg__InteractiveMarkerControl__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        visualization_msgs__msg__InteractiveMarkerControl__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__msg__InteractiveMarkerControl__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerControl__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__msg__InteractiveMarkerControl__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__msg__InteractiveMarkerControl__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerControl__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerControl__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerControl__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct visualization_msgs__msg__InteractiveMarker {
    pub header: std_msgs__msg__Header,
    pub pose: geometry_msgs__msg__Pose,
    pub name: rosidl_runtime_c__String,
    pub description: rosidl_runtime_c__String,
    pub scale: f32,
    pub menu_entries: visualization_msgs__msg__MenuEntry__Sequence,
    pub controls: visualization_msgs__msg__InteractiveMarkerControl__Sequence,
}
#[test]
fn bindgen_test_layout_visualization_msgs__msg__InteractiveMarker() {
    const UNINIT: ::std::mem::MaybeUninit<visualization_msgs__msg__InteractiveMarker> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__msg__InteractiveMarker>(),
        192usize,
        concat!(
            "Size of: ",
            stringify!(visualization_msgs__msg__InteractiveMarker)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__msg__InteractiveMarker>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__msg__InteractiveMarker)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarker),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pose) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarker),
            "::",
            stringify!(pose)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarker),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).description) as usize - ptr as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarker),
            "::",
            stringify!(description)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).scale) as usize - ptr as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarker),
            "::",
            stringify!(scale)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).menu_entries) as usize - ptr as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarker),
            "::",
            stringify!(menu_entries)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).controls) as usize - ptr as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarker),
            "::",
            stringify!(controls)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct visualization_msgs__msg__InteractiveMarker__Sequence {
    pub data: *mut visualization_msgs__msg__InteractiveMarker,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_visualization_msgs__msg__InteractiveMarker__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<visualization_msgs__msg__InteractiveMarker__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__msg__InteractiveMarker__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(visualization_msgs__msg__InteractiveMarker__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__msg__InteractiveMarker__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__msg__InteractiveMarker__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarker__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarker__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarker__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const visualization_msgs__msg__InteractiveMarkerFeedback__KEEP_ALIVE: _bindgen_ty_273 =
    _bindgen_ty_273::visualization_msgs__msg__InteractiveMarkerFeedback__KEEP_ALIVE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_273 {
    visualization_msgs__msg__InteractiveMarkerFeedback__KEEP_ALIVE = 0,
}
pub const visualization_msgs__msg__InteractiveMarkerFeedback__POSE_UPDATE: _bindgen_ty_274 =
    _bindgen_ty_274::visualization_msgs__msg__InteractiveMarkerFeedback__POSE_UPDATE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_274 {
    visualization_msgs__msg__InteractiveMarkerFeedback__POSE_UPDATE = 1,
}
pub const visualization_msgs__msg__InteractiveMarkerFeedback__MENU_SELECT: _bindgen_ty_275 =
    _bindgen_ty_275::visualization_msgs__msg__InteractiveMarkerFeedback__MENU_SELECT;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_275 {
    visualization_msgs__msg__InteractiveMarkerFeedback__MENU_SELECT = 2,
}
pub const visualization_msgs__msg__InteractiveMarkerFeedback__BUTTON_CLICK: _bindgen_ty_276 =
    _bindgen_ty_276::visualization_msgs__msg__InteractiveMarkerFeedback__BUTTON_CLICK;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_276 {
    visualization_msgs__msg__InteractiveMarkerFeedback__BUTTON_CLICK = 3,
}
pub const visualization_msgs__msg__InteractiveMarkerFeedback__MOUSE_DOWN: _bindgen_ty_277 =
    _bindgen_ty_277::visualization_msgs__msg__InteractiveMarkerFeedback__MOUSE_DOWN;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_277 {
    visualization_msgs__msg__InteractiveMarkerFeedback__MOUSE_DOWN = 4,
}
pub const visualization_msgs__msg__InteractiveMarkerFeedback__MOUSE_UP: _bindgen_ty_278 =
    _bindgen_ty_278::visualization_msgs__msg__InteractiveMarkerFeedback__MOUSE_UP;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_278 {
    visualization_msgs__msg__InteractiveMarkerFeedback__MOUSE_UP = 5,
}
#[repr(C)]
pub struct visualization_msgs__msg__InteractiveMarkerFeedback {
    pub header: std_msgs__msg__Header,
    pub client_id: rosidl_runtime_c__String,
    pub marker_name: rosidl_runtime_c__String,
    pub control_name: rosidl_runtime_c__String,
    pub event_type: u8,
    pub pose: geometry_msgs__msg__Pose,
    pub menu_entry_id: u32,
    pub mouse_point: geometry_msgs__msg__Point,
    pub mouse_point_valid: bool,
}
#[test]
fn bindgen_test_layout_visualization_msgs__msg__InteractiveMarkerFeedback() {
    const UNINIT: ::std::mem::MaybeUninit<visualization_msgs__msg__InteractiveMarkerFeedback> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__msg__InteractiveMarkerFeedback>(),
        208usize,
        concat!(
            "Size of: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerFeedback)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__msg__InteractiveMarkerFeedback>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__msg__InteractiveMarkerFeedback)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerFeedback),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).client_id) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerFeedback),
            "::",
            stringify!(client_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).marker_name) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerFeedback),
            "::",
            stringify!(marker_name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).control_name) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerFeedback),
            "::",
            stringify!(control_name)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).event_type) as usize - ptr as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerFeedback),
            "::",
            stringify!(event_type)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pose) as usize - ptr as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerFeedback),
            "::",
            stringify!(pose)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).menu_entry_id) as usize - ptr as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerFeedback),
            "::",
            stringify!(menu_entry_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mouse_point) as usize - ptr as usize },
        176usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerFeedback),
            "::",
            stringify!(mouse_point)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mouse_point_valid) as usize - ptr as usize },
        200usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerFeedback),
            "::",
            stringify!(mouse_point_valid)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct visualization_msgs__msg__InteractiveMarkerFeedback__Sequence {
    pub data: *mut visualization_msgs__msg__InteractiveMarkerFeedback,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_visualization_msgs__msg__InteractiveMarkerFeedback__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        visualization_msgs__msg__InteractiveMarkerFeedback__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__msg__InteractiveMarkerFeedback__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerFeedback__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__msg__InteractiveMarkerFeedback__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__msg__InteractiveMarkerFeedback__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerFeedback__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerFeedback__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerFeedback__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct visualization_msgs__msg__InteractiveMarkerInit {
    pub server_id: rosidl_runtime_c__String,
    pub seq_num: u64,
    pub markers: visualization_msgs__msg__InteractiveMarker__Sequence,
}
#[test]
fn bindgen_test_layout_visualization_msgs__msg__InteractiveMarkerInit() {
    const UNINIT: ::std::mem::MaybeUninit<visualization_msgs__msg__InteractiveMarkerInit> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__msg__InteractiveMarkerInit>(),
        56usize,
        concat!(
            "Size of: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerInit)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__msg__InteractiveMarkerInit>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__msg__InteractiveMarkerInit)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).server_id) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerInit),
            "::",
            stringify!(server_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).seq_num) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerInit),
            "::",
            stringify!(seq_num)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).markers) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerInit),
            "::",
            stringify!(markers)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct visualization_msgs__msg__InteractiveMarkerInit__Sequence {
    pub data: *mut visualization_msgs__msg__InteractiveMarkerInit,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_visualization_msgs__msg__InteractiveMarkerInit__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        visualization_msgs__msg__InteractiveMarkerInit__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__msg__InteractiveMarkerInit__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerInit__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__msg__InteractiveMarkerInit__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__msg__InteractiveMarkerInit__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerInit__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerInit__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerInit__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
pub struct visualization_msgs__msg__InteractiveMarkerPose {
    pub header: std_msgs__msg__Header,
    pub pose: geometry_msgs__msg__Pose,
    pub name: rosidl_runtime_c__String,
}
#[test]
fn bindgen_test_layout_visualization_msgs__msg__InteractiveMarkerPose() {
    const UNINIT: ::std::mem::MaybeUninit<visualization_msgs__msg__InteractiveMarkerPose> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__msg__InteractiveMarkerPose>(),
        112usize,
        concat!(
            "Size of: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerPose)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__msg__InteractiveMarkerPose>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__msg__InteractiveMarkerPose)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerPose),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pose) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerPose),
            "::",
            stringify!(pose)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerPose),
            "::",
            stringify!(name)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct visualization_msgs__msg__InteractiveMarkerPose__Sequence {
    pub data: *mut visualization_msgs__msg__InteractiveMarkerPose,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_visualization_msgs__msg__InteractiveMarkerPose__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        visualization_msgs__msg__InteractiveMarkerPose__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__msg__InteractiveMarkerPose__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerPose__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__msg__InteractiveMarkerPose__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__msg__InteractiveMarkerPose__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerPose__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerPose__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerPose__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
pub const visualization_msgs__msg__InteractiveMarkerUpdate__KEEP_ALIVE: _bindgen_ty_279 =
    _bindgen_ty_279::visualization_msgs__msg__InteractiveMarkerUpdate__KEEP_ALIVE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_279 {
    visualization_msgs__msg__InteractiveMarkerUpdate__KEEP_ALIVE = 0,
}
pub const visualization_msgs__msg__InteractiveMarkerUpdate__UPDATE: _bindgen_ty_280 =
    _bindgen_ty_280::visualization_msgs__msg__InteractiveMarkerUpdate__UPDATE;
#[repr(u32)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_280 {
    visualization_msgs__msg__InteractiveMarkerUpdate__UPDATE = 1,
}
#[repr(C)]
pub struct visualization_msgs__msg__InteractiveMarkerUpdate {
    pub server_id: rosidl_runtime_c__String,
    pub seq_num: u64,
    pub type_: u8,
    pub markers: visualization_msgs__msg__InteractiveMarker__Sequence,
    pub poses: visualization_msgs__msg__InteractiveMarkerPose__Sequence,
    pub erases: rosidl_runtime_c__String__Sequence,
}
#[test]
fn bindgen_test_layout_visualization_msgs__msg__InteractiveMarkerUpdate() {
    const UNINIT: ::std::mem::MaybeUninit<visualization_msgs__msg__InteractiveMarkerUpdate> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__msg__InteractiveMarkerUpdate>(),
        112usize,
        concat!(
            "Size of: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerUpdate)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__msg__InteractiveMarkerUpdate>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__msg__InteractiveMarkerUpdate)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).server_id) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerUpdate),
            "::",
            stringify!(server_id)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).seq_num) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerUpdate),
            "::",
            stringify!(seq_num)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerUpdate),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).markers) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerUpdate),
            "::",
            stringify!(markers)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).poses) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerUpdate),
            "::",
            stringify!(poses)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).erases) as usize - ptr as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerUpdate),
            "::",
            stringify!(erases)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct visualization_msgs__msg__InteractiveMarkerUpdate__Sequence {
    pub data: *mut visualization_msgs__msg__InteractiveMarkerUpdate,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_visualization_msgs__msg__InteractiveMarkerUpdate__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        visualization_msgs__msg__InteractiveMarkerUpdate__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__msg__InteractiveMarkerUpdate__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerUpdate__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__msg__InteractiveMarkerUpdate__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__msg__InteractiveMarkerUpdate__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerUpdate__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerUpdate__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__InteractiveMarkerUpdate__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct visualization_msgs__msg__MarkerArray {
    pub markers: visualization_msgs__msg__Marker__Sequence,
}
#[test]
fn bindgen_test_layout_visualization_msgs__msg__MarkerArray() {
    const UNINIT: ::std::mem::MaybeUninit<visualization_msgs__msg__MarkerArray> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__msg__MarkerArray>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(visualization_msgs__msg__MarkerArray)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__msg__MarkerArray>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__msg__MarkerArray)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).markers) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__MarkerArray),
            "::",
            stringify!(markers)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct visualization_msgs__msg__MarkerArray__Sequence {
    pub data: *mut visualization_msgs__msg__MarkerArray,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_visualization_msgs__msg__MarkerArray__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<visualization_msgs__msg__MarkerArray__Sequence> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__msg__MarkerArray__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(visualization_msgs__msg__MarkerArray__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__msg__MarkerArray__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__msg__MarkerArray__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__MarkerArray__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__MarkerArray__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__msg__MarkerArray__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct visualization_msgs__srv__GetInteractiveMarkers_Request {
    pub structure_needs_at_least_one_member: u8,
}
#[test]
fn bindgen_test_layout_visualization_msgs__srv__GetInteractiveMarkers_Request() {
    const UNINIT: ::std::mem::MaybeUninit<visualization_msgs__srv__GetInteractiveMarkers_Request> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__srv__GetInteractiveMarkers_Request>(),
        1usize,
        concat!(
            "Size of: ",
            stringify!(visualization_msgs__srv__GetInteractiveMarkers_Request)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__srv__GetInteractiveMarkers_Request>(),
        1usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__srv__GetInteractiveMarkers_Request)
        )
    );
    assert_eq!(
        unsafe {
            ::std::ptr::addr_of!((*ptr).structure_needs_at_least_one_member) as usize - ptr as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__srv__GetInteractiveMarkers_Request),
            "::",
            stringify!(structure_needs_at_least_one_member)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct visualization_msgs__srv__GetInteractiveMarkers_Request__Sequence {
    pub data: *mut visualization_msgs__srv__GetInteractiveMarkers_Request,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_visualization_msgs__srv__GetInteractiveMarkers_Request__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        visualization_msgs__srv__GetInteractiveMarkers_Request__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__srv__GetInteractiveMarkers_Request__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(visualization_msgs__srv__GetInteractiveMarkers_Request__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__srv__GetInteractiveMarkers_Request__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__srv__GetInteractiveMarkers_Request__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__srv__GetInteractiveMarkers_Request__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__srv__GetInteractiveMarkers_Request__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__srv__GetInteractiveMarkers_Request__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct visualization_msgs__srv__GetInteractiveMarkers_Response {
    pub sequence_number: u64,
    pub markers: visualization_msgs__msg__InteractiveMarker__Sequence,
}
#[test]
fn bindgen_test_layout_visualization_msgs__srv__GetInteractiveMarkers_Response() {
    const UNINIT: ::std::mem::MaybeUninit<visualization_msgs__srv__GetInteractiveMarkers_Response> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__srv__GetInteractiveMarkers_Response>(),
        32usize,
        concat!(
            "Size of: ",
            stringify!(visualization_msgs__srv__GetInteractiveMarkers_Response)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__srv__GetInteractiveMarkers_Response>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__srv__GetInteractiveMarkers_Response)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sequence_number) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__srv__GetInteractiveMarkers_Response),
            "::",
            stringify!(sequence_number)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).markers) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__srv__GetInteractiveMarkers_Response),
            "::",
            stringify!(markers)
        )
    );
}
#[repr(C)]
#[derive(Debug)]
pub struct visualization_msgs__srv__GetInteractiveMarkers_Response__Sequence {
    pub data: *mut visualization_msgs__srv__GetInteractiveMarkers_Response,
    pub size: usize,
    pub capacity: usize,
}
#[test]
fn bindgen_test_layout_visualization_msgs__srv__GetInteractiveMarkers_Response__Sequence() {
    const UNINIT: ::std::mem::MaybeUninit<
        visualization_msgs__srv__GetInteractiveMarkers_Response__Sequence,
    > = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<visualization_msgs__srv__GetInteractiveMarkers_Response__Sequence>(),
        24usize,
        concat!(
            "Size of: ",
            stringify!(visualization_msgs__srv__GetInteractiveMarkers_Response__Sequence)
        )
    );
    assert_eq!(
        ::std::mem::align_of::<visualization_msgs__srv__GetInteractiveMarkers_Response__Sequence>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(visualization_msgs__srv__GetInteractiveMarkers_Response__Sequence)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__srv__GetInteractiveMarkers_Response__Sequence),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__srv__GetInteractiveMarkers_Response__Sequence),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(visualization_msgs__srv__GetInteractiveMarkers_Response__Sequence),
            "::",
            stringify!(capacity)
        )
    );
}
extern "C" {
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__action_msgs__msg__GoalInfo(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__action_msgs__msg__GoalStatus(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__action_msgs__msg__GoalStatusArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn action_msgs__msg__GoalInfo__create() -> *mut action_msgs__msg__GoalInfo;
    pub fn action_msgs__msg__GoalInfo__destroy(msg: *mut action_msgs__msg__GoalInfo);
    pub fn action_msgs__msg__GoalInfo__Sequence__init(
        array: *mut action_msgs__msg__GoalInfo__Sequence,
        size: usize,
    ) -> bool;
    pub fn action_msgs__msg__GoalInfo__Sequence__fini(
        array: *mut action_msgs__msg__GoalInfo__Sequence,
    );
    pub fn action_msgs__msg__GoalInfo__Sequence__create(
        size: usize,
    ) -> *mut action_msgs__msg__GoalInfo__Sequence;
    pub fn action_msgs__msg__GoalInfo__Sequence__destroy(
        array: *mut action_msgs__msg__GoalInfo__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__action_msgs__msg__GoalInfo(
    ) -> *const rosidl_message_type_support_t;
    pub fn action_msgs__msg__GoalStatus__create() -> *mut action_msgs__msg__GoalStatus;
    pub fn action_msgs__msg__GoalStatus__destroy(msg: *mut action_msgs__msg__GoalStatus);
    pub fn action_msgs__msg__GoalStatus__Sequence__init(
        array: *mut action_msgs__msg__GoalStatus__Sequence,
        size: usize,
    ) -> bool;
    pub fn action_msgs__msg__GoalStatus__Sequence__fini(
        array: *mut action_msgs__msg__GoalStatus__Sequence,
    );
    pub fn action_msgs__msg__GoalStatus__Sequence__create(
        size: usize,
    ) -> *mut action_msgs__msg__GoalStatus__Sequence;
    pub fn action_msgs__msg__GoalStatus__Sequence__destroy(
        array: *mut action_msgs__msg__GoalStatus__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__action_msgs__msg__GoalStatus(
    ) -> *const rosidl_message_type_support_t;
    pub fn action_msgs__msg__GoalStatusArray__create() -> *mut action_msgs__msg__GoalStatusArray;
    pub fn action_msgs__msg__GoalStatusArray__destroy(msg: *mut action_msgs__msg__GoalStatusArray);
    pub fn action_msgs__msg__GoalStatusArray__Sequence__init(
        array: *mut action_msgs__msg__GoalStatusArray__Sequence,
        size: usize,
    ) -> bool;
    pub fn action_msgs__msg__GoalStatusArray__Sequence__fini(
        array: *mut action_msgs__msg__GoalStatusArray__Sequence,
    );
    pub fn action_msgs__msg__GoalStatusArray__Sequence__create(
        size: usize,
    ) -> *mut action_msgs__msg__GoalStatusArray__Sequence;
    pub fn action_msgs__msg__GoalStatusArray__Sequence__destroy(
        array: *mut action_msgs__msg__GoalStatusArray__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__action_msgs__msg__GoalStatusArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn action_msgs__srv__CancelGoal_Request__create(
    ) -> *mut action_msgs__srv__CancelGoal_Request;
    pub fn action_msgs__srv__CancelGoal_Request__destroy(
        msg: *mut action_msgs__srv__CancelGoal_Request,
    );
    pub fn action_msgs__srv__CancelGoal_Request__Sequence__init(
        array: *mut action_msgs__srv__CancelGoal_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn action_msgs__srv__CancelGoal_Request__Sequence__fini(
        array: *mut action_msgs__srv__CancelGoal_Request__Sequence,
    );
    pub fn action_msgs__srv__CancelGoal_Request__Sequence__create(
        size: usize,
    ) -> *mut action_msgs__srv__CancelGoal_Request__Sequence;
    pub fn action_msgs__srv__CancelGoal_Request__Sequence__destroy(
        array: *mut action_msgs__srv__CancelGoal_Request__Sequence,
    );
    pub fn action_msgs__srv__CancelGoal_Response__create(
    ) -> *mut action_msgs__srv__CancelGoal_Response;
    pub fn action_msgs__srv__CancelGoal_Response__destroy(
        msg: *mut action_msgs__srv__CancelGoal_Response,
    );
    pub fn action_msgs__srv__CancelGoal_Response__Sequence__init(
        array: *mut action_msgs__srv__CancelGoal_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn action_msgs__srv__CancelGoal_Response__Sequence__fini(
        array: *mut action_msgs__srv__CancelGoal_Response__Sequence,
    );
    pub fn action_msgs__srv__CancelGoal_Response__Sequence__create(
        size: usize,
    ) -> *mut action_msgs__srv__CancelGoal_Response__Sequence;
    pub fn action_msgs__srv__CancelGoal_Response__Sequence__destroy(
        array: *mut action_msgs__srv__CancelGoal_Response__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__action_msgs__srv__CancelGoal_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__action_msgs__srv__CancelGoal_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__action_msgs__srv__CancelGoal(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__action_msgs__srv__CancelGoal_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__action_msgs__srv__CancelGoal_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__action_msgs__srv__CancelGoal(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__builtin_interfaces__msg__Duration(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__builtin_interfaces__msg__Time(
    ) -> *const rosidl_message_type_support_t;
    pub fn builtin_interfaces__msg__Duration__create() -> *mut builtin_interfaces__msg__Duration;
    pub fn builtin_interfaces__msg__Duration__destroy(msg: *mut builtin_interfaces__msg__Duration);
    pub fn builtin_interfaces__msg__Duration__Sequence__init(
        array: *mut builtin_interfaces__msg__Duration__Sequence,
        size: usize,
    ) -> bool;
    pub fn builtin_interfaces__msg__Duration__Sequence__fini(
        array: *mut builtin_interfaces__msg__Duration__Sequence,
    );
    pub fn builtin_interfaces__msg__Duration__Sequence__create(
        size: usize,
    ) -> *mut builtin_interfaces__msg__Duration__Sequence;
    pub fn builtin_interfaces__msg__Duration__Sequence__destroy(
        array: *mut builtin_interfaces__msg__Duration__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__builtin_interfaces__msg__Duration(
    ) -> *const rosidl_message_type_support_t;
    pub fn builtin_interfaces__msg__Time__create() -> *mut builtin_interfaces__msg__Time;
    pub fn builtin_interfaces__msg__Time__destroy(msg: *mut builtin_interfaces__msg__Time);
    pub fn builtin_interfaces__msg__Time__Sequence__init(
        array: *mut builtin_interfaces__msg__Time__Sequence,
        size: usize,
    ) -> bool;
    pub fn builtin_interfaces__msg__Time__Sequence__fini(
        array: *mut builtin_interfaces__msg__Time__Sequence,
    );
    pub fn builtin_interfaces__msg__Time__Sequence__create(
        size: usize,
    ) -> *mut builtin_interfaces__msg__Time__Sequence;
    pub fn builtin_interfaces__msg__Time__Sequence__destroy(
        array: *mut builtin_interfaces__msg__Time__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__builtin_interfaces__msg__Time(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__diagnostic_msgs__msg__DiagnosticArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__diagnostic_msgs__msg__DiagnosticStatus(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__diagnostic_msgs__msg__KeyValue(
    ) -> *const rosidl_message_type_support_t;
    pub fn diagnostic_msgs__msg__DiagnosticArray__create(
    ) -> *mut diagnostic_msgs__msg__DiagnosticArray;
    pub fn diagnostic_msgs__msg__DiagnosticArray__destroy(
        msg: *mut diagnostic_msgs__msg__DiagnosticArray,
    );
    pub fn diagnostic_msgs__msg__DiagnosticArray__Sequence__init(
        array: *mut diagnostic_msgs__msg__DiagnosticArray__Sequence,
        size: usize,
    ) -> bool;
    pub fn diagnostic_msgs__msg__DiagnosticArray__Sequence__fini(
        array: *mut diagnostic_msgs__msg__DiagnosticArray__Sequence,
    );
    pub fn diagnostic_msgs__msg__DiagnosticArray__Sequence__create(
        size: usize,
    ) -> *mut diagnostic_msgs__msg__DiagnosticArray__Sequence;
    pub fn diagnostic_msgs__msg__DiagnosticArray__Sequence__destroy(
        array: *mut diagnostic_msgs__msg__DiagnosticArray__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__diagnostic_msgs__msg__DiagnosticArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn diagnostic_msgs__msg__DiagnosticStatus__create(
    ) -> *mut diagnostic_msgs__msg__DiagnosticStatus;
    pub fn diagnostic_msgs__msg__DiagnosticStatus__destroy(
        msg: *mut diagnostic_msgs__msg__DiagnosticStatus,
    );
    pub fn diagnostic_msgs__msg__DiagnosticStatus__Sequence__init(
        array: *mut diagnostic_msgs__msg__DiagnosticStatus__Sequence,
        size: usize,
    ) -> bool;
    pub fn diagnostic_msgs__msg__DiagnosticStatus__Sequence__fini(
        array: *mut diagnostic_msgs__msg__DiagnosticStatus__Sequence,
    );
    pub fn diagnostic_msgs__msg__DiagnosticStatus__Sequence__create(
        size: usize,
    ) -> *mut diagnostic_msgs__msg__DiagnosticStatus__Sequence;
    pub fn diagnostic_msgs__msg__DiagnosticStatus__Sequence__destroy(
        array: *mut diagnostic_msgs__msg__DiagnosticStatus__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__diagnostic_msgs__msg__DiagnosticStatus(
    ) -> *const rosidl_message_type_support_t;
    pub fn diagnostic_msgs__msg__KeyValue__create() -> *mut diagnostic_msgs__msg__KeyValue;
    pub fn diagnostic_msgs__msg__KeyValue__destroy(msg: *mut diagnostic_msgs__msg__KeyValue);
    pub fn diagnostic_msgs__msg__KeyValue__Sequence__init(
        array: *mut diagnostic_msgs__msg__KeyValue__Sequence,
        size: usize,
    ) -> bool;
    pub fn diagnostic_msgs__msg__KeyValue__Sequence__fini(
        array: *mut diagnostic_msgs__msg__KeyValue__Sequence,
    );
    pub fn diagnostic_msgs__msg__KeyValue__Sequence__create(
        size: usize,
    ) -> *mut diagnostic_msgs__msg__KeyValue__Sequence;
    pub fn diagnostic_msgs__msg__KeyValue__Sequence__destroy(
        array: *mut diagnostic_msgs__msg__KeyValue__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__diagnostic_msgs__msg__KeyValue(
    ) -> *const rosidl_message_type_support_t;
    pub fn diagnostic_msgs__srv__AddDiagnostics_Request__create(
    ) -> *mut diagnostic_msgs__srv__AddDiagnostics_Request;
    pub fn diagnostic_msgs__srv__AddDiagnostics_Request__destroy(
        msg: *mut diagnostic_msgs__srv__AddDiagnostics_Request,
    );
    pub fn diagnostic_msgs__srv__AddDiagnostics_Request__Sequence__init(
        array: *mut diagnostic_msgs__srv__AddDiagnostics_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn diagnostic_msgs__srv__AddDiagnostics_Request__Sequence__fini(
        array: *mut diagnostic_msgs__srv__AddDiagnostics_Request__Sequence,
    );
    pub fn diagnostic_msgs__srv__AddDiagnostics_Request__Sequence__create(
        size: usize,
    ) -> *mut diagnostic_msgs__srv__AddDiagnostics_Request__Sequence;
    pub fn diagnostic_msgs__srv__AddDiagnostics_Request__Sequence__destroy(
        array: *mut diagnostic_msgs__srv__AddDiagnostics_Request__Sequence,
    );
    pub fn diagnostic_msgs__srv__AddDiagnostics_Response__create(
    ) -> *mut diagnostic_msgs__srv__AddDiagnostics_Response;
    pub fn diagnostic_msgs__srv__AddDiagnostics_Response__destroy(
        msg: *mut diagnostic_msgs__srv__AddDiagnostics_Response,
    );
    pub fn diagnostic_msgs__srv__AddDiagnostics_Response__Sequence__init(
        array: *mut diagnostic_msgs__srv__AddDiagnostics_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn diagnostic_msgs__srv__AddDiagnostics_Response__Sequence__fini(
        array: *mut diagnostic_msgs__srv__AddDiagnostics_Response__Sequence,
    );
    pub fn diagnostic_msgs__srv__AddDiagnostics_Response__Sequence__create(
        size: usize,
    ) -> *mut diagnostic_msgs__srv__AddDiagnostics_Response__Sequence;
    pub fn diagnostic_msgs__srv__AddDiagnostics_Response__Sequence__destroy(
        array: *mut diagnostic_msgs__srv__AddDiagnostics_Response__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__diagnostic_msgs__srv__AddDiagnostics_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__diagnostic_msgs__srv__AddDiagnostics_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__diagnostic_msgs__srv__AddDiagnostics(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__diagnostic_msgs__srv__AddDiagnostics_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__diagnostic_msgs__srv__AddDiagnostics_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__diagnostic_msgs__srv__AddDiagnostics(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__diagnostic_msgs__srv__SelfTest_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__diagnostic_msgs__srv__SelfTest_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__diagnostic_msgs__srv__SelfTest(
    ) -> *const rosidl_service_type_support_t;
    pub fn diagnostic_msgs__srv__SelfTest_Request__create(
    ) -> *mut diagnostic_msgs__srv__SelfTest_Request;
    pub fn diagnostic_msgs__srv__SelfTest_Request__destroy(
        msg: *mut diagnostic_msgs__srv__SelfTest_Request,
    );
    pub fn diagnostic_msgs__srv__SelfTest_Request__Sequence__init(
        array: *mut diagnostic_msgs__srv__SelfTest_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn diagnostic_msgs__srv__SelfTest_Request__Sequence__fini(
        array: *mut diagnostic_msgs__srv__SelfTest_Request__Sequence,
    );
    pub fn diagnostic_msgs__srv__SelfTest_Request__Sequence__create(
        size: usize,
    ) -> *mut diagnostic_msgs__srv__SelfTest_Request__Sequence;
    pub fn diagnostic_msgs__srv__SelfTest_Request__Sequence__destroy(
        array: *mut diagnostic_msgs__srv__SelfTest_Request__Sequence,
    );
    pub fn diagnostic_msgs__srv__SelfTest_Response__create(
    ) -> *mut diagnostic_msgs__srv__SelfTest_Response;
    pub fn diagnostic_msgs__srv__SelfTest_Response__destroy(
        msg: *mut diagnostic_msgs__srv__SelfTest_Response,
    );
    pub fn diagnostic_msgs__srv__SelfTest_Response__Sequence__init(
        array: *mut diagnostic_msgs__srv__SelfTest_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn diagnostic_msgs__srv__SelfTest_Response__Sequence__fini(
        array: *mut diagnostic_msgs__srv__SelfTest_Response__Sequence,
    );
    pub fn diagnostic_msgs__srv__SelfTest_Response__Sequence__create(
        size: usize,
    ) -> *mut diagnostic_msgs__srv__SelfTest_Response__Sequence;
    pub fn diagnostic_msgs__srv__SelfTest_Response__Sequence__destroy(
        array: *mut diagnostic_msgs__srv__SelfTest_Response__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__diagnostic_msgs__srv__SelfTest_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__diagnostic_msgs__srv__SelfTest_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__diagnostic_msgs__srv__SelfTest(
    ) -> *const rosidl_service_type_support_t;
    pub fn geometry_msgs__msg__Accel__create() -> *mut geometry_msgs__msg__Accel;
    pub fn geometry_msgs__msg__Accel__destroy(msg: *mut geometry_msgs__msg__Accel);
    pub fn geometry_msgs__msg__Accel__Sequence__init(
        array: *mut geometry_msgs__msg__Accel__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__Accel__Sequence__fini(
        array: *mut geometry_msgs__msg__Accel__Sequence,
    );
    pub fn geometry_msgs__msg__Accel__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__Accel__Sequence;
    pub fn geometry_msgs__msg__Accel__Sequence__destroy(
        array: *mut geometry_msgs__msg__Accel__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__Accel(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__AccelStamped__create() -> *mut geometry_msgs__msg__AccelStamped;
    pub fn geometry_msgs__msg__AccelStamped__destroy(msg: *mut geometry_msgs__msg__AccelStamped);
    pub fn geometry_msgs__msg__AccelStamped__Sequence__init(
        array: *mut geometry_msgs__msg__AccelStamped__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__AccelStamped__Sequence__fini(
        array: *mut geometry_msgs__msg__AccelStamped__Sequence,
    );
    pub fn geometry_msgs__msg__AccelStamped__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__AccelStamped__Sequence;
    pub fn geometry_msgs__msg__AccelStamped__Sequence__destroy(
        array: *mut geometry_msgs__msg__AccelStamped__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__AccelStamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__AccelWithCovariance__create(
    ) -> *mut geometry_msgs__msg__AccelWithCovariance;
    pub fn geometry_msgs__msg__AccelWithCovariance__destroy(
        msg: *mut geometry_msgs__msg__AccelWithCovariance,
    );
    pub fn geometry_msgs__msg__AccelWithCovariance__Sequence__init(
        array: *mut geometry_msgs__msg__AccelWithCovariance__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__AccelWithCovariance__Sequence__fini(
        array: *mut geometry_msgs__msg__AccelWithCovariance__Sequence,
    );
    pub fn geometry_msgs__msg__AccelWithCovariance__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__AccelWithCovariance__Sequence;
    pub fn geometry_msgs__msg__AccelWithCovariance__Sequence__destroy(
        array: *mut geometry_msgs__msg__AccelWithCovariance__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__AccelWithCovariance(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__AccelWithCovarianceStamped__create(
    ) -> *mut geometry_msgs__msg__AccelWithCovarianceStamped;
    pub fn geometry_msgs__msg__AccelWithCovarianceStamped__destroy(
        msg: *mut geometry_msgs__msg__AccelWithCovarianceStamped,
    );
    pub fn geometry_msgs__msg__AccelWithCovarianceStamped__Sequence__init(
        array: *mut geometry_msgs__msg__AccelWithCovarianceStamped__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__AccelWithCovarianceStamped__Sequence__fini(
        array: *mut geometry_msgs__msg__AccelWithCovarianceStamped__Sequence,
    );
    pub fn geometry_msgs__msg__AccelWithCovarianceStamped__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__AccelWithCovarianceStamped__Sequence;
    pub fn geometry_msgs__msg__AccelWithCovarianceStamped__Sequence__destroy(
        array: *mut geometry_msgs__msg__AccelWithCovarianceStamped__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__AccelWithCovarianceStamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__Accel(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__AccelStamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__AccelWithCovariance(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__AccelWithCovarianceStamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__Inertia(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__InertiaStamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__Point32(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__Point(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__PointStamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__Polygon(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__PolygonStamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__Pose2D(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__Pose(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__PoseArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__PoseStamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__PoseWithCovariance(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__PoseWithCovarianceStamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__Quaternion(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__QuaternionStamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__Transform(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__TransformStamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__Twist(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__TwistStamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__TwistWithCovariance(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__TwistWithCovarianceStamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__Vector3(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__Vector3Stamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__Wrench(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__geometry_msgs__msg__WrenchStamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__Inertia__create() -> *mut geometry_msgs__msg__Inertia;
    pub fn geometry_msgs__msg__Inertia__destroy(msg: *mut geometry_msgs__msg__Inertia);
    pub fn geometry_msgs__msg__Inertia__Sequence__init(
        array: *mut geometry_msgs__msg__Inertia__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__Inertia__Sequence__fini(
        array: *mut geometry_msgs__msg__Inertia__Sequence,
    );
    pub fn geometry_msgs__msg__Inertia__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__Inertia__Sequence;
    pub fn geometry_msgs__msg__Inertia__Sequence__destroy(
        array: *mut geometry_msgs__msg__Inertia__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__Inertia(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__InertiaStamped__create() -> *mut geometry_msgs__msg__InertiaStamped;
    pub fn geometry_msgs__msg__InertiaStamped__destroy(
        msg: *mut geometry_msgs__msg__InertiaStamped,
    );
    pub fn geometry_msgs__msg__InertiaStamped__Sequence__init(
        array: *mut geometry_msgs__msg__InertiaStamped__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__InertiaStamped__Sequence__fini(
        array: *mut geometry_msgs__msg__InertiaStamped__Sequence,
    );
    pub fn geometry_msgs__msg__InertiaStamped__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__InertiaStamped__Sequence;
    pub fn geometry_msgs__msg__InertiaStamped__Sequence__destroy(
        array: *mut geometry_msgs__msg__InertiaStamped__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__InertiaStamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__Point__create() -> *mut geometry_msgs__msg__Point;
    pub fn geometry_msgs__msg__Point__destroy(msg: *mut geometry_msgs__msg__Point);
    pub fn geometry_msgs__msg__Point__Sequence__init(
        array: *mut geometry_msgs__msg__Point__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__Point__Sequence__fini(
        array: *mut geometry_msgs__msg__Point__Sequence,
    );
    pub fn geometry_msgs__msg__Point__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__Point__Sequence;
    pub fn geometry_msgs__msg__Point__Sequence__destroy(
        array: *mut geometry_msgs__msg__Point__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__Point(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__Point32__create() -> *mut geometry_msgs__msg__Point32;
    pub fn geometry_msgs__msg__Point32__destroy(msg: *mut geometry_msgs__msg__Point32);
    pub fn geometry_msgs__msg__Point32__Sequence__init(
        array: *mut geometry_msgs__msg__Point32__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__Point32__Sequence__fini(
        array: *mut geometry_msgs__msg__Point32__Sequence,
    );
    pub fn geometry_msgs__msg__Point32__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__Point32__Sequence;
    pub fn geometry_msgs__msg__Point32__Sequence__destroy(
        array: *mut geometry_msgs__msg__Point32__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__Point32(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__PointStamped__create() -> *mut geometry_msgs__msg__PointStamped;
    pub fn geometry_msgs__msg__PointStamped__destroy(msg: *mut geometry_msgs__msg__PointStamped);
    pub fn geometry_msgs__msg__PointStamped__Sequence__init(
        array: *mut geometry_msgs__msg__PointStamped__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__PointStamped__Sequence__fini(
        array: *mut geometry_msgs__msg__PointStamped__Sequence,
    );
    pub fn geometry_msgs__msg__PointStamped__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__PointStamped__Sequence;
    pub fn geometry_msgs__msg__PointStamped__Sequence__destroy(
        array: *mut geometry_msgs__msg__PointStamped__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__PointStamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__Polygon__create() -> *mut geometry_msgs__msg__Polygon;
    pub fn geometry_msgs__msg__Polygon__destroy(msg: *mut geometry_msgs__msg__Polygon);
    pub fn geometry_msgs__msg__Polygon__Sequence__init(
        array: *mut geometry_msgs__msg__Polygon__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__Polygon__Sequence__fini(
        array: *mut geometry_msgs__msg__Polygon__Sequence,
    );
    pub fn geometry_msgs__msg__Polygon__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__Polygon__Sequence;
    pub fn geometry_msgs__msg__Polygon__Sequence__destroy(
        array: *mut geometry_msgs__msg__Polygon__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__Polygon(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__PolygonStamped__create() -> *mut geometry_msgs__msg__PolygonStamped;
    pub fn geometry_msgs__msg__PolygonStamped__destroy(
        msg: *mut geometry_msgs__msg__PolygonStamped,
    );
    pub fn geometry_msgs__msg__PolygonStamped__Sequence__init(
        array: *mut geometry_msgs__msg__PolygonStamped__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__PolygonStamped__Sequence__fini(
        array: *mut geometry_msgs__msg__PolygonStamped__Sequence,
    );
    pub fn geometry_msgs__msg__PolygonStamped__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__PolygonStamped__Sequence;
    pub fn geometry_msgs__msg__PolygonStamped__Sequence__destroy(
        array: *mut geometry_msgs__msg__PolygonStamped__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__PolygonStamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__Pose__create() -> *mut geometry_msgs__msg__Pose;
    pub fn geometry_msgs__msg__Pose__destroy(msg: *mut geometry_msgs__msg__Pose);
    pub fn geometry_msgs__msg__Pose__Sequence__init(
        array: *mut geometry_msgs__msg__Pose__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__Pose__Sequence__fini(array: *mut geometry_msgs__msg__Pose__Sequence);
    pub fn geometry_msgs__msg__Pose__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__Pose__Sequence;
    pub fn geometry_msgs__msg__Pose__Sequence__destroy(
        array: *mut geometry_msgs__msg__Pose__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__Pose(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__Pose2D__create() -> *mut geometry_msgs__msg__Pose2D;
    pub fn geometry_msgs__msg__Pose2D__destroy(msg: *mut geometry_msgs__msg__Pose2D);
    pub fn geometry_msgs__msg__Pose2D__Sequence__init(
        array: *mut geometry_msgs__msg__Pose2D__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__Pose2D__Sequence__fini(
        array: *mut geometry_msgs__msg__Pose2D__Sequence,
    );
    pub fn geometry_msgs__msg__Pose2D__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__Pose2D__Sequence;
    pub fn geometry_msgs__msg__Pose2D__Sequence__destroy(
        array: *mut geometry_msgs__msg__Pose2D__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__Pose2D(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__PoseArray__create() -> *mut geometry_msgs__msg__PoseArray;
    pub fn geometry_msgs__msg__PoseArray__destroy(msg: *mut geometry_msgs__msg__PoseArray);
    pub fn geometry_msgs__msg__PoseArray__Sequence__init(
        array: *mut geometry_msgs__msg__PoseArray__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__PoseArray__Sequence__fini(
        array: *mut geometry_msgs__msg__PoseArray__Sequence,
    );
    pub fn geometry_msgs__msg__PoseArray__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__PoseArray__Sequence;
    pub fn geometry_msgs__msg__PoseArray__Sequence__destroy(
        array: *mut geometry_msgs__msg__PoseArray__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__PoseArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__PoseStamped__create() -> *mut geometry_msgs__msg__PoseStamped;
    pub fn geometry_msgs__msg__PoseStamped__destroy(msg: *mut geometry_msgs__msg__PoseStamped);
    pub fn geometry_msgs__msg__PoseStamped__Sequence__init(
        array: *mut geometry_msgs__msg__PoseStamped__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__PoseStamped__Sequence__fini(
        array: *mut geometry_msgs__msg__PoseStamped__Sequence,
    );
    pub fn geometry_msgs__msg__PoseStamped__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__PoseStamped__Sequence;
    pub fn geometry_msgs__msg__PoseStamped__Sequence__destroy(
        array: *mut geometry_msgs__msg__PoseStamped__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__PoseStamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__PoseWithCovariance__create(
    ) -> *mut geometry_msgs__msg__PoseWithCovariance;
    pub fn geometry_msgs__msg__PoseWithCovariance__destroy(
        msg: *mut geometry_msgs__msg__PoseWithCovariance,
    );
    pub fn geometry_msgs__msg__PoseWithCovariance__Sequence__init(
        array: *mut geometry_msgs__msg__PoseWithCovariance__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__PoseWithCovariance__Sequence__fini(
        array: *mut geometry_msgs__msg__PoseWithCovariance__Sequence,
    );
    pub fn geometry_msgs__msg__PoseWithCovariance__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__PoseWithCovariance__Sequence;
    pub fn geometry_msgs__msg__PoseWithCovariance__Sequence__destroy(
        array: *mut geometry_msgs__msg__PoseWithCovariance__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__PoseWithCovariance(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__PoseWithCovarianceStamped__create(
    ) -> *mut geometry_msgs__msg__PoseWithCovarianceStamped;
    pub fn geometry_msgs__msg__PoseWithCovarianceStamped__destroy(
        msg: *mut geometry_msgs__msg__PoseWithCovarianceStamped,
    );
    pub fn geometry_msgs__msg__PoseWithCovarianceStamped__Sequence__init(
        array: *mut geometry_msgs__msg__PoseWithCovarianceStamped__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__PoseWithCovarianceStamped__Sequence__fini(
        array: *mut geometry_msgs__msg__PoseWithCovarianceStamped__Sequence,
    );
    pub fn geometry_msgs__msg__PoseWithCovarianceStamped__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__PoseWithCovarianceStamped__Sequence;
    pub fn geometry_msgs__msg__PoseWithCovarianceStamped__Sequence__destroy(
        array: *mut geometry_msgs__msg__PoseWithCovarianceStamped__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__PoseWithCovarianceStamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__Quaternion__create() -> *mut geometry_msgs__msg__Quaternion;
    pub fn geometry_msgs__msg__Quaternion__destroy(msg: *mut geometry_msgs__msg__Quaternion);
    pub fn geometry_msgs__msg__Quaternion__Sequence__init(
        array: *mut geometry_msgs__msg__Quaternion__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__Quaternion__Sequence__fini(
        array: *mut geometry_msgs__msg__Quaternion__Sequence,
    );
    pub fn geometry_msgs__msg__Quaternion__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__Quaternion__Sequence;
    pub fn geometry_msgs__msg__Quaternion__Sequence__destroy(
        array: *mut geometry_msgs__msg__Quaternion__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__Quaternion(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__QuaternionStamped__create(
    ) -> *mut geometry_msgs__msg__QuaternionStamped;
    pub fn geometry_msgs__msg__QuaternionStamped__destroy(
        msg: *mut geometry_msgs__msg__QuaternionStamped,
    );
    pub fn geometry_msgs__msg__QuaternionStamped__Sequence__init(
        array: *mut geometry_msgs__msg__QuaternionStamped__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__QuaternionStamped__Sequence__fini(
        array: *mut geometry_msgs__msg__QuaternionStamped__Sequence,
    );
    pub fn geometry_msgs__msg__QuaternionStamped__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__QuaternionStamped__Sequence;
    pub fn geometry_msgs__msg__QuaternionStamped__Sequence__destroy(
        array: *mut geometry_msgs__msg__QuaternionStamped__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__QuaternionStamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__Transform__create() -> *mut geometry_msgs__msg__Transform;
    pub fn geometry_msgs__msg__Transform__destroy(msg: *mut geometry_msgs__msg__Transform);
    pub fn geometry_msgs__msg__Transform__Sequence__init(
        array: *mut geometry_msgs__msg__Transform__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__Transform__Sequence__fini(
        array: *mut geometry_msgs__msg__Transform__Sequence,
    );
    pub fn geometry_msgs__msg__Transform__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__Transform__Sequence;
    pub fn geometry_msgs__msg__Transform__Sequence__destroy(
        array: *mut geometry_msgs__msg__Transform__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__Transform(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__TransformStamped__create(
    ) -> *mut geometry_msgs__msg__TransformStamped;
    pub fn geometry_msgs__msg__TransformStamped__destroy(
        msg: *mut geometry_msgs__msg__TransformStamped,
    );
    pub fn geometry_msgs__msg__TransformStamped__Sequence__init(
        array: *mut geometry_msgs__msg__TransformStamped__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__TransformStamped__Sequence__fini(
        array: *mut geometry_msgs__msg__TransformStamped__Sequence,
    );
    pub fn geometry_msgs__msg__TransformStamped__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__TransformStamped__Sequence;
    pub fn geometry_msgs__msg__TransformStamped__Sequence__destroy(
        array: *mut geometry_msgs__msg__TransformStamped__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__TransformStamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__Twist__create() -> *mut geometry_msgs__msg__Twist;
    pub fn geometry_msgs__msg__Twist__destroy(msg: *mut geometry_msgs__msg__Twist);
    pub fn geometry_msgs__msg__Twist__Sequence__init(
        array: *mut geometry_msgs__msg__Twist__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__Twist__Sequence__fini(
        array: *mut geometry_msgs__msg__Twist__Sequence,
    );
    pub fn geometry_msgs__msg__Twist__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__Twist__Sequence;
    pub fn geometry_msgs__msg__Twist__Sequence__destroy(
        array: *mut geometry_msgs__msg__Twist__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__Twist(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__TwistStamped__create() -> *mut geometry_msgs__msg__TwistStamped;
    pub fn geometry_msgs__msg__TwistStamped__destroy(msg: *mut geometry_msgs__msg__TwistStamped);
    pub fn geometry_msgs__msg__TwistStamped__Sequence__init(
        array: *mut geometry_msgs__msg__TwistStamped__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__TwistStamped__Sequence__fini(
        array: *mut geometry_msgs__msg__TwistStamped__Sequence,
    );
    pub fn geometry_msgs__msg__TwistStamped__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__TwistStamped__Sequence;
    pub fn geometry_msgs__msg__TwistStamped__Sequence__destroy(
        array: *mut geometry_msgs__msg__TwistStamped__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__TwistStamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__TwistWithCovariance__create(
    ) -> *mut geometry_msgs__msg__TwistWithCovariance;
    pub fn geometry_msgs__msg__TwistWithCovariance__destroy(
        msg: *mut geometry_msgs__msg__TwistWithCovariance,
    );
    pub fn geometry_msgs__msg__TwistWithCovariance__Sequence__init(
        array: *mut geometry_msgs__msg__TwistWithCovariance__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__TwistWithCovariance__Sequence__fini(
        array: *mut geometry_msgs__msg__TwistWithCovariance__Sequence,
    );
    pub fn geometry_msgs__msg__TwistWithCovariance__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__TwistWithCovariance__Sequence;
    pub fn geometry_msgs__msg__TwistWithCovariance__Sequence__destroy(
        array: *mut geometry_msgs__msg__TwistWithCovariance__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__TwistWithCovariance(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__TwistWithCovarianceStamped__create(
    ) -> *mut geometry_msgs__msg__TwistWithCovarianceStamped;
    pub fn geometry_msgs__msg__TwistWithCovarianceStamped__destroy(
        msg: *mut geometry_msgs__msg__TwistWithCovarianceStamped,
    );
    pub fn geometry_msgs__msg__TwistWithCovarianceStamped__Sequence__init(
        array: *mut geometry_msgs__msg__TwistWithCovarianceStamped__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__TwistWithCovarianceStamped__Sequence__fini(
        array: *mut geometry_msgs__msg__TwistWithCovarianceStamped__Sequence,
    );
    pub fn geometry_msgs__msg__TwistWithCovarianceStamped__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__TwistWithCovarianceStamped__Sequence;
    pub fn geometry_msgs__msg__TwistWithCovarianceStamped__Sequence__destroy(
        array: *mut geometry_msgs__msg__TwistWithCovarianceStamped__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__TwistWithCovarianceStamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__Vector3__create() -> *mut geometry_msgs__msg__Vector3;
    pub fn geometry_msgs__msg__Vector3__destroy(msg: *mut geometry_msgs__msg__Vector3);
    pub fn geometry_msgs__msg__Vector3__Sequence__init(
        array: *mut geometry_msgs__msg__Vector3__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__Vector3__Sequence__fini(
        array: *mut geometry_msgs__msg__Vector3__Sequence,
    );
    pub fn geometry_msgs__msg__Vector3__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__Vector3__Sequence;
    pub fn geometry_msgs__msg__Vector3__Sequence__destroy(
        array: *mut geometry_msgs__msg__Vector3__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__Vector3(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__Vector3Stamped__create() -> *mut geometry_msgs__msg__Vector3Stamped;
    pub fn geometry_msgs__msg__Vector3Stamped__destroy(
        msg: *mut geometry_msgs__msg__Vector3Stamped,
    );
    pub fn geometry_msgs__msg__Vector3Stamped__Sequence__init(
        array: *mut geometry_msgs__msg__Vector3Stamped__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__Vector3Stamped__Sequence__fini(
        array: *mut geometry_msgs__msg__Vector3Stamped__Sequence,
    );
    pub fn geometry_msgs__msg__Vector3Stamped__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__Vector3Stamped__Sequence;
    pub fn geometry_msgs__msg__Vector3Stamped__Sequence__destroy(
        array: *mut geometry_msgs__msg__Vector3Stamped__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__Vector3Stamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__Wrench__create() -> *mut geometry_msgs__msg__Wrench;
    pub fn geometry_msgs__msg__Wrench__destroy(msg: *mut geometry_msgs__msg__Wrench);
    pub fn geometry_msgs__msg__Wrench__Sequence__init(
        array: *mut geometry_msgs__msg__Wrench__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__Wrench__Sequence__fini(
        array: *mut geometry_msgs__msg__Wrench__Sequence,
    );
    pub fn geometry_msgs__msg__Wrench__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__Wrench__Sequence;
    pub fn geometry_msgs__msg__Wrench__Sequence__destroy(
        array: *mut geometry_msgs__msg__Wrench__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__Wrench(
    ) -> *const rosidl_message_type_support_t;
    pub fn geometry_msgs__msg__WrenchStamped__create() -> *mut geometry_msgs__msg__WrenchStamped;
    pub fn geometry_msgs__msg__WrenchStamped__destroy(msg: *mut geometry_msgs__msg__WrenchStamped);
    pub fn geometry_msgs__msg__WrenchStamped__Sequence__init(
        array: *mut geometry_msgs__msg__WrenchStamped__Sequence,
        size: usize,
    ) -> bool;
    pub fn geometry_msgs__msg__WrenchStamped__Sequence__fini(
        array: *mut geometry_msgs__msg__WrenchStamped__Sequence,
    );
    pub fn geometry_msgs__msg__WrenchStamped__Sequence__create(
        size: usize,
    ) -> *mut geometry_msgs__msg__WrenchStamped__Sequence;
    pub fn geometry_msgs__msg__WrenchStamped__Sequence__destroy(
        array: *mut geometry_msgs__msg__WrenchStamped__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__geometry_msgs__msg__WrenchStamped(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__lifecycle_msgs__msg__State(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__lifecycle_msgs__msg__Transition(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__lifecycle_msgs__msg__TransitionDescription(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__lifecycle_msgs__msg__TransitionEvent(
    ) -> *const rosidl_message_type_support_t;
    pub fn lifecycle_msgs__msg__State__create() -> *mut lifecycle_msgs__msg__State;
    pub fn lifecycle_msgs__msg__State__destroy(msg: *mut lifecycle_msgs__msg__State);
    pub fn lifecycle_msgs__msg__State__Sequence__init(
        array: *mut lifecycle_msgs__msg__State__Sequence,
        size: usize,
    ) -> bool;
    pub fn lifecycle_msgs__msg__State__Sequence__fini(
        array: *mut lifecycle_msgs__msg__State__Sequence,
    );
    pub fn lifecycle_msgs__msg__State__Sequence__create(
        size: usize,
    ) -> *mut lifecycle_msgs__msg__State__Sequence;
    pub fn lifecycle_msgs__msg__State__Sequence__destroy(
        array: *mut lifecycle_msgs__msg__State__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__lifecycle_msgs__msg__State(
    ) -> *const rosidl_message_type_support_t;
    pub fn lifecycle_msgs__msg__Transition__create() -> *mut lifecycle_msgs__msg__Transition;
    pub fn lifecycle_msgs__msg__Transition__destroy(msg: *mut lifecycle_msgs__msg__Transition);
    pub fn lifecycle_msgs__msg__Transition__Sequence__init(
        array: *mut lifecycle_msgs__msg__Transition__Sequence,
        size: usize,
    ) -> bool;
    pub fn lifecycle_msgs__msg__Transition__Sequence__fini(
        array: *mut lifecycle_msgs__msg__Transition__Sequence,
    );
    pub fn lifecycle_msgs__msg__Transition__Sequence__create(
        size: usize,
    ) -> *mut lifecycle_msgs__msg__Transition__Sequence;
    pub fn lifecycle_msgs__msg__Transition__Sequence__destroy(
        array: *mut lifecycle_msgs__msg__Transition__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__lifecycle_msgs__msg__Transition(
    ) -> *const rosidl_message_type_support_t;
    pub fn lifecycle_msgs__msg__TransitionDescription__create(
    ) -> *mut lifecycle_msgs__msg__TransitionDescription;
    pub fn lifecycle_msgs__msg__TransitionDescription__destroy(
        msg: *mut lifecycle_msgs__msg__TransitionDescription,
    );
    pub fn lifecycle_msgs__msg__TransitionDescription__Sequence__init(
        array: *mut lifecycle_msgs__msg__TransitionDescription__Sequence,
        size: usize,
    ) -> bool;
    pub fn lifecycle_msgs__msg__TransitionDescription__Sequence__fini(
        array: *mut lifecycle_msgs__msg__TransitionDescription__Sequence,
    );
    pub fn lifecycle_msgs__msg__TransitionDescription__Sequence__create(
        size: usize,
    ) -> *mut lifecycle_msgs__msg__TransitionDescription__Sequence;
    pub fn lifecycle_msgs__msg__TransitionDescription__Sequence__destroy(
        array: *mut lifecycle_msgs__msg__TransitionDescription__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__lifecycle_msgs__msg__TransitionDescription(
    ) -> *const rosidl_message_type_support_t;
    pub fn lifecycle_msgs__msg__TransitionEvent__create(
    ) -> *mut lifecycle_msgs__msg__TransitionEvent;
    pub fn lifecycle_msgs__msg__TransitionEvent__destroy(
        msg: *mut lifecycle_msgs__msg__TransitionEvent,
    );
    pub fn lifecycle_msgs__msg__TransitionEvent__Sequence__init(
        array: *mut lifecycle_msgs__msg__TransitionEvent__Sequence,
        size: usize,
    ) -> bool;
    pub fn lifecycle_msgs__msg__TransitionEvent__Sequence__fini(
        array: *mut lifecycle_msgs__msg__TransitionEvent__Sequence,
    );
    pub fn lifecycle_msgs__msg__TransitionEvent__Sequence__create(
        size: usize,
    ) -> *mut lifecycle_msgs__msg__TransitionEvent__Sequence;
    pub fn lifecycle_msgs__msg__TransitionEvent__Sequence__destroy(
        array: *mut lifecycle_msgs__msg__TransitionEvent__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__lifecycle_msgs__msg__TransitionEvent(
    ) -> *const rosidl_message_type_support_t;
    pub fn lifecycle_msgs__srv__ChangeState_Request__create(
    ) -> *mut lifecycle_msgs__srv__ChangeState_Request;
    pub fn lifecycle_msgs__srv__ChangeState_Request__destroy(
        msg: *mut lifecycle_msgs__srv__ChangeState_Request,
    );
    pub fn lifecycle_msgs__srv__ChangeState_Request__Sequence__init(
        array: *mut lifecycle_msgs__srv__ChangeState_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn lifecycle_msgs__srv__ChangeState_Request__Sequence__fini(
        array: *mut lifecycle_msgs__srv__ChangeState_Request__Sequence,
    );
    pub fn lifecycle_msgs__srv__ChangeState_Request__Sequence__create(
        size: usize,
    ) -> *mut lifecycle_msgs__srv__ChangeState_Request__Sequence;
    pub fn lifecycle_msgs__srv__ChangeState_Request__Sequence__destroy(
        array: *mut lifecycle_msgs__srv__ChangeState_Request__Sequence,
    );
    pub fn lifecycle_msgs__srv__ChangeState_Response__create(
    ) -> *mut lifecycle_msgs__srv__ChangeState_Response;
    pub fn lifecycle_msgs__srv__ChangeState_Response__destroy(
        msg: *mut lifecycle_msgs__srv__ChangeState_Response,
    );
    pub fn lifecycle_msgs__srv__ChangeState_Response__Sequence__init(
        array: *mut lifecycle_msgs__srv__ChangeState_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn lifecycle_msgs__srv__ChangeState_Response__Sequence__fini(
        array: *mut lifecycle_msgs__srv__ChangeState_Response__Sequence,
    );
    pub fn lifecycle_msgs__srv__ChangeState_Response__Sequence__create(
        size: usize,
    ) -> *mut lifecycle_msgs__srv__ChangeState_Response__Sequence;
    pub fn lifecycle_msgs__srv__ChangeState_Response__Sequence__destroy(
        array: *mut lifecycle_msgs__srv__ChangeState_Response__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__lifecycle_msgs__srv__ChangeState_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__lifecycle_msgs__srv__ChangeState_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__lifecycle_msgs__srv__ChangeState(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__lifecycle_msgs__srv__ChangeState_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__lifecycle_msgs__srv__ChangeState_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__lifecycle_msgs__srv__ChangeState(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__lifecycle_msgs__srv__GetAvailableStates_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__lifecycle_msgs__srv__GetAvailableStates_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__lifecycle_msgs__srv__GetAvailableStates(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__lifecycle_msgs__srv__GetAvailableTransitions_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__lifecycle_msgs__srv__GetAvailableTransitions_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__lifecycle_msgs__srv__GetAvailableTransitions(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__lifecycle_msgs__srv__GetState_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__lifecycle_msgs__srv__GetState_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__lifecycle_msgs__srv__GetState(
    ) -> *const rosidl_service_type_support_t;
    pub fn lifecycle_msgs__srv__GetAvailableStates_Request__create(
    ) -> *mut lifecycle_msgs__srv__GetAvailableStates_Request;
    pub fn lifecycle_msgs__srv__GetAvailableStates_Request__destroy(
        msg: *mut lifecycle_msgs__srv__GetAvailableStates_Request,
    );
    pub fn lifecycle_msgs__srv__GetAvailableStates_Request__Sequence__init(
        array: *mut lifecycle_msgs__srv__GetAvailableStates_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn lifecycle_msgs__srv__GetAvailableStates_Request__Sequence__fini(
        array: *mut lifecycle_msgs__srv__GetAvailableStates_Request__Sequence,
    );
    pub fn lifecycle_msgs__srv__GetAvailableStates_Request__Sequence__create(
        size: usize,
    ) -> *mut lifecycle_msgs__srv__GetAvailableStates_Request__Sequence;
    pub fn lifecycle_msgs__srv__GetAvailableStates_Request__Sequence__destroy(
        array: *mut lifecycle_msgs__srv__GetAvailableStates_Request__Sequence,
    );
    pub fn lifecycle_msgs__srv__GetAvailableStates_Response__create(
    ) -> *mut lifecycle_msgs__srv__GetAvailableStates_Response;
    pub fn lifecycle_msgs__srv__GetAvailableStates_Response__destroy(
        msg: *mut lifecycle_msgs__srv__GetAvailableStates_Response,
    );
    pub fn lifecycle_msgs__srv__GetAvailableStates_Response__Sequence__init(
        array: *mut lifecycle_msgs__srv__GetAvailableStates_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn lifecycle_msgs__srv__GetAvailableStates_Response__Sequence__fini(
        array: *mut lifecycle_msgs__srv__GetAvailableStates_Response__Sequence,
    );
    pub fn lifecycle_msgs__srv__GetAvailableStates_Response__Sequence__create(
        size: usize,
    ) -> *mut lifecycle_msgs__srv__GetAvailableStates_Response__Sequence;
    pub fn lifecycle_msgs__srv__GetAvailableStates_Response__Sequence__destroy(
        array: *mut lifecycle_msgs__srv__GetAvailableStates_Response__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__lifecycle_msgs__srv__GetAvailableStates_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__lifecycle_msgs__srv__GetAvailableStates_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__lifecycle_msgs__srv__GetAvailableStates(
    ) -> *const rosidl_service_type_support_t;
    pub fn lifecycle_msgs__srv__GetAvailableTransitions_Request__create(
    ) -> *mut lifecycle_msgs__srv__GetAvailableTransitions_Request;
    pub fn lifecycle_msgs__srv__GetAvailableTransitions_Request__destroy(
        msg: *mut lifecycle_msgs__srv__GetAvailableTransitions_Request,
    );
    pub fn lifecycle_msgs__srv__GetAvailableTransitions_Request__Sequence__init(
        array: *mut lifecycle_msgs__srv__GetAvailableTransitions_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn lifecycle_msgs__srv__GetAvailableTransitions_Request__Sequence__fini(
        array: *mut lifecycle_msgs__srv__GetAvailableTransitions_Request__Sequence,
    );
    pub fn lifecycle_msgs__srv__GetAvailableTransitions_Request__Sequence__create(
        size: usize,
    ) -> *mut lifecycle_msgs__srv__GetAvailableTransitions_Request__Sequence;
    pub fn lifecycle_msgs__srv__GetAvailableTransitions_Request__Sequence__destroy(
        array: *mut lifecycle_msgs__srv__GetAvailableTransitions_Request__Sequence,
    );
    pub fn lifecycle_msgs__srv__GetAvailableTransitions_Response__create(
    ) -> *mut lifecycle_msgs__srv__GetAvailableTransitions_Response;
    pub fn lifecycle_msgs__srv__GetAvailableTransitions_Response__destroy(
        msg: *mut lifecycle_msgs__srv__GetAvailableTransitions_Response,
    );
    pub fn lifecycle_msgs__srv__GetAvailableTransitions_Response__Sequence__init(
        array: *mut lifecycle_msgs__srv__GetAvailableTransitions_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn lifecycle_msgs__srv__GetAvailableTransitions_Response__Sequence__fini(
        array: *mut lifecycle_msgs__srv__GetAvailableTransitions_Response__Sequence,
    );
    pub fn lifecycle_msgs__srv__GetAvailableTransitions_Response__Sequence__create(
        size: usize,
    ) -> *mut lifecycle_msgs__srv__GetAvailableTransitions_Response__Sequence;
    pub fn lifecycle_msgs__srv__GetAvailableTransitions_Response__Sequence__destroy(
        array: *mut lifecycle_msgs__srv__GetAvailableTransitions_Response__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__lifecycle_msgs__srv__GetAvailableTransitions_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__lifecycle_msgs__srv__GetAvailableTransitions_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__lifecycle_msgs__srv__GetAvailableTransitions(
    ) -> *const rosidl_service_type_support_t;
    pub fn lifecycle_msgs__srv__GetState_Request__create(
    ) -> *mut lifecycle_msgs__srv__GetState_Request;
    pub fn lifecycle_msgs__srv__GetState_Request__destroy(
        msg: *mut lifecycle_msgs__srv__GetState_Request,
    );
    pub fn lifecycle_msgs__srv__GetState_Request__Sequence__init(
        array: *mut lifecycle_msgs__srv__GetState_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn lifecycle_msgs__srv__GetState_Request__Sequence__fini(
        array: *mut lifecycle_msgs__srv__GetState_Request__Sequence,
    );
    pub fn lifecycle_msgs__srv__GetState_Request__Sequence__create(
        size: usize,
    ) -> *mut lifecycle_msgs__srv__GetState_Request__Sequence;
    pub fn lifecycle_msgs__srv__GetState_Request__Sequence__destroy(
        array: *mut lifecycle_msgs__srv__GetState_Request__Sequence,
    );
    pub fn lifecycle_msgs__srv__GetState_Response__create(
    ) -> *mut lifecycle_msgs__srv__GetState_Response;
    pub fn lifecycle_msgs__srv__GetState_Response__destroy(
        msg: *mut lifecycle_msgs__srv__GetState_Response,
    );
    pub fn lifecycle_msgs__srv__GetState_Response__Sequence__init(
        array: *mut lifecycle_msgs__srv__GetState_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn lifecycle_msgs__srv__GetState_Response__Sequence__fini(
        array: *mut lifecycle_msgs__srv__GetState_Response__Sequence,
    );
    pub fn lifecycle_msgs__srv__GetState_Response__Sequence__create(
        size: usize,
    ) -> *mut lifecycle_msgs__srv__GetState_Response__Sequence;
    pub fn lifecycle_msgs__srv__GetState_Response__Sequence__destroy(
        array: *mut lifecycle_msgs__srv__GetState_Response__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__lifecycle_msgs__srv__GetState_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__lifecycle_msgs__srv__GetState_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__lifecycle_msgs__srv__GetState(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__nav_msgs__msg__GridCells(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__nav_msgs__msg__MapMetaData(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__nav_msgs__msg__OccupancyGrid(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__nav_msgs__msg__Odometry(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__nav_msgs__msg__Path(
    ) -> *const rosidl_message_type_support_t;
    pub fn nav_msgs__msg__GridCells__create() -> *mut nav_msgs__msg__GridCells;
    pub fn nav_msgs__msg__GridCells__destroy(msg: *mut nav_msgs__msg__GridCells);
    pub fn nav_msgs__msg__GridCells__Sequence__init(
        array: *mut nav_msgs__msg__GridCells__Sequence,
        size: usize,
    ) -> bool;
    pub fn nav_msgs__msg__GridCells__Sequence__fini(array: *mut nav_msgs__msg__GridCells__Sequence);
    pub fn nav_msgs__msg__GridCells__Sequence__create(
        size: usize,
    ) -> *mut nav_msgs__msg__GridCells__Sequence;
    pub fn nav_msgs__msg__GridCells__Sequence__destroy(
        array: *mut nav_msgs__msg__GridCells__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__nav_msgs__msg__GridCells(
    ) -> *const rosidl_message_type_support_t;
    pub fn nav_msgs__msg__MapMetaData__create() -> *mut nav_msgs__msg__MapMetaData;
    pub fn nav_msgs__msg__MapMetaData__destroy(msg: *mut nav_msgs__msg__MapMetaData);
    pub fn nav_msgs__msg__MapMetaData__Sequence__init(
        array: *mut nav_msgs__msg__MapMetaData__Sequence,
        size: usize,
    ) -> bool;
    pub fn nav_msgs__msg__MapMetaData__Sequence__fini(
        array: *mut nav_msgs__msg__MapMetaData__Sequence,
    );
    pub fn nav_msgs__msg__MapMetaData__Sequence__create(
        size: usize,
    ) -> *mut nav_msgs__msg__MapMetaData__Sequence;
    pub fn nav_msgs__msg__MapMetaData__Sequence__destroy(
        array: *mut nav_msgs__msg__MapMetaData__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__nav_msgs__msg__MapMetaData(
    ) -> *const rosidl_message_type_support_t;
    pub fn nav_msgs__msg__OccupancyGrid__create() -> *mut nav_msgs__msg__OccupancyGrid;
    pub fn nav_msgs__msg__OccupancyGrid__destroy(msg: *mut nav_msgs__msg__OccupancyGrid);
    pub fn nav_msgs__msg__OccupancyGrid__Sequence__init(
        array: *mut nav_msgs__msg__OccupancyGrid__Sequence,
        size: usize,
    ) -> bool;
    pub fn nav_msgs__msg__OccupancyGrid__Sequence__fini(
        array: *mut nav_msgs__msg__OccupancyGrid__Sequence,
    );
    pub fn nav_msgs__msg__OccupancyGrid__Sequence__create(
        size: usize,
    ) -> *mut nav_msgs__msg__OccupancyGrid__Sequence;
    pub fn nav_msgs__msg__OccupancyGrid__Sequence__destroy(
        array: *mut nav_msgs__msg__OccupancyGrid__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__nav_msgs__msg__OccupancyGrid(
    ) -> *const rosidl_message_type_support_t;
    pub fn nav_msgs__msg__Odometry__create() -> *mut nav_msgs__msg__Odometry;
    pub fn nav_msgs__msg__Odometry__destroy(msg: *mut nav_msgs__msg__Odometry);
    pub fn nav_msgs__msg__Odometry__Sequence__init(
        array: *mut nav_msgs__msg__Odometry__Sequence,
        size: usize,
    ) -> bool;
    pub fn nav_msgs__msg__Odometry__Sequence__fini(array: *mut nav_msgs__msg__Odometry__Sequence);
    pub fn nav_msgs__msg__Odometry__Sequence__create(
        size: usize,
    ) -> *mut nav_msgs__msg__Odometry__Sequence;
    pub fn nav_msgs__msg__Odometry__Sequence__destroy(
        array: *mut nav_msgs__msg__Odometry__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__nav_msgs__msg__Odometry(
    ) -> *const rosidl_message_type_support_t;
    pub fn nav_msgs__msg__Path__create() -> *mut nav_msgs__msg__Path;
    pub fn nav_msgs__msg__Path__destroy(msg: *mut nav_msgs__msg__Path);
    pub fn nav_msgs__msg__Path__Sequence__init(
        array: *mut nav_msgs__msg__Path__Sequence,
        size: usize,
    ) -> bool;
    pub fn nav_msgs__msg__Path__Sequence__fini(array: *mut nav_msgs__msg__Path__Sequence);
    pub fn nav_msgs__msg__Path__Sequence__create(size: usize)
        -> *mut nav_msgs__msg__Path__Sequence;
    pub fn nav_msgs__msg__Path__Sequence__destroy(array: *mut nav_msgs__msg__Path__Sequence);
    pub fn rosidl_typesupport_c__get_message_type_support_handle__nav_msgs__msg__Path(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__nav_msgs__srv__GetMap_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__nav_msgs__srv__GetMap_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__nav_msgs__srv__GetMap(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__nav_msgs__srv__GetPlan_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__nav_msgs__srv__GetPlan_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__nav_msgs__srv__GetPlan(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__nav_msgs__srv__LoadMap_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__nav_msgs__srv__LoadMap_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__nav_msgs__srv__LoadMap(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__nav_msgs__srv__SetMap_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__nav_msgs__srv__SetMap_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__nav_msgs__srv__SetMap(
    ) -> *const rosidl_service_type_support_t;
    pub fn nav_msgs__srv__GetMap_Request__create() -> *mut nav_msgs__srv__GetMap_Request;
    pub fn nav_msgs__srv__GetMap_Request__destroy(msg: *mut nav_msgs__srv__GetMap_Request);
    pub fn nav_msgs__srv__GetMap_Request__Sequence__init(
        array: *mut nav_msgs__srv__GetMap_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn nav_msgs__srv__GetMap_Request__Sequence__fini(
        array: *mut nav_msgs__srv__GetMap_Request__Sequence,
    );
    pub fn nav_msgs__srv__GetMap_Request__Sequence__create(
        size: usize,
    ) -> *mut nav_msgs__srv__GetMap_Request__Sequence;
    pub fn nav_msgs__srv__GetMap_Request__Sequence__destroy(
        array: *mut nav_msgs__srv__GetMap_Request__Sequence,
    );
    pub fn nav_msgs__srv__GetMap_Response__create() -> *mut nav_msgs__srv__GetMap_Response;
    pub fn nav_msgs__srv__GetMap_Response__destroy(msg: *mut nav_msgs__srv__GetMap_Response);
    pub fn nav_msgs__srv__GetMap_Response__Sequence__init(
        array: *mut nav_msgs__srv__GetMap_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn nav_msgs__srv__GetMap_Response__Sequence__fini(
        array: *mut nav_msgs__srv__GetMap_Response__Sequence,
    );
    pub fn nav_msgs__srv__GetMap_Response__Sequence__create(
        size: usize,
    ) -> *mut nav_msgs__srv__GetMap_Response__Sequence;
    pub fn nav_msgs__srv__GetMap_Response__Sequence__destroy(
        array: *mut nav_msgs__srv__GetMap_Response__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__nav_msgs__srv__GetMap_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__nav_msgs__srv__GetMap_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__nav_msgs__srv__GetMap(
    ) -> *const rosidl_service_type_support_t;
    pub fn nav_msgs__srv__GetPlan_Request__create() -> *mut nav_msgs__srv__GetPlan_Request;
    pub fn nav_msgs__srv__GetPlan_Request__destroy(msg: *mut nav_msgs__srv__GetPlan_Request);
    pub fn nav_msgs__srv__GetPlan_Request__Sequence__init(
        array: *mut nav_msgs__srv__GetPlan_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn nav_msgs__srv__GetPlan_Request__Sequence__fini(
        array: *mut nav_msgs__srv__GetPlan_Request__Sequence,
    );
    pub fn nav_msgs__srv__GetPlan_Request__Sequence__create(
        size: usize,
    ) -> *mut nav_msgs__srv__GetPlan_Request__Sequence;
    pub fn nav_msgs__srv__GetPlan_Request__Sequence__destroy(
        array: *mut nav_msgs__srv__GetPlan_Request__Sequence,
    );
    pub fn nav_msgs__srv__GetPlan_Response__create() -> *mut nav_msgs__srv__GetPlan_Response;
    pub fn nav_msgs__srv__GetPlan_Response__destroy(msg: *mut nav_msgs__srv__GetPlan_Response);
    pub fn nav_msgs__srv__GetPlan_Response__Sequence__init(
        array: *mut nav_msgs__srv__GetPlan_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn nav_msgs__srv__GetPlan_Response__Sequence__fini(
        array: *mut nav_msgs__srv__GetPlan_Response__Sequence,
    );
    pub fn nav_msgs__srv__GetPlan_Response__Sequence__create(
        size: usize,
    ) -> *mut nav_msgs__srv__GetPlan_Response__Sequence;
    pub fn nav_msgs__srv__GetPlan_Response__Sequence__destroy(
        array: *mut nav_msgs__srv__GetPlan_Response__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__nav_msgs__srv__GetPlan_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__nav_msgs__srv__GetPlan_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__nav_msgs__srv__GetPlan(
    ) -> *const rosidl_service_type_support_t;
    pub fn nav_msgs__srv__LoadMap_Request__create() -> *mut nav_msgs__srv__LoadMap_Request;
    pub fn nav_msgs__srv__LoadMap_Request__destroy(msg: *mut nav_msgs__srv__LoadMap_Request);
    pub fn nav_msgs__srv__LoadMap_Request__Sequence__init(
        array: *mut nav_msgs__srv__LoadMap_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn nav_msgs__srv__LoadMap_Request__Sequence__fini(
        array: *mut nav_msgs__srv__LoadMap_Request__Sequence,
    );
    pub fn nav_msgs__srv__LoadMap_Request__Sequence__create(
        size: usize,
    ) -> *mut nav_msgs__srv__LoadMap_Request__Sequence;
    pub fn nav_msgs__srv__LoadMap_Request__Sequence__destroy(
        array: *mut nav_msgs__srv__LoadMap_Request__Sequence,
    );
    pub fn nav_msgs__srv__LoadMap_Response__create() -> *mut nav_msgs__srv__LoadMap_Response;
    pub fn nav_msgs__srv__LoadMap_Response__destroy(msg: *mut nav_msgs__srv__LoadMap_Response);
    pub fn nav_msgs__srv__LoadMap_Response__Sequence__init(
        array: *mut nav_msgs__srv__LoadMap_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn nav_msgs__srv__LoadMap_Response__Sequence__fini(
        array: *mut nav_msgs__srv__LoadMap_Response__Sequence,
    );
    pub fn nav_msgs__srv__LoadMap_Response__Sequence__create(
        size: usize,
    ) -> *mut nav_msgs__srv__LoadMap_Response__Sequence;
    pub fn nav_msgs__srv__LoadMap_Response__Sequence__destroy(
        array: *mut nav_msgs__srv__LoadMap_Response__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__nav_msgs__srv__LoadMap_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__nav_msgs__srv__LoadMap_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__nav_msgs__srv__LoadMap(
    ) -> *const rosidl_service_type_support_t;
    pub fn nav_msgs__srv__SetMap_Request__create() -> *mut nav_msgs__srv__SetMap_Request;
    pub fn nav_msgs__srv__SetMap_Request__destroy(msg: *mut nav_msgs__srv__SetMap_Request);
    pub fn nav_msgs__srv__SetMap_Request__Sequence__init(
        array: *mut nav_msgs__srv__SetMap_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn nav_msgs__srv__SetMap_Request__Sequence__fini(
        array: *mut nav_msgs__srv__SetMap_Request__Sequence,
    );
    pub fn nav_msgs__srv__SetMap_Request__Sequence__create(
        size: usize,
    ) -> *mut nav_msgs__srv__SetMap_Request__Sequence;
    pub fn nav_msgs__srv__SetMap_Request__Sequence__destroy(
        array: *mut nav_msgs__srv__SetMap_Request__Sequence,
    );
    pub fn nav_msgs__srv__SetMap_Response__create() -> *mut nav_msgs__srv__SetMap_Response;
    pub fn nav_msgs__srv__SetMap_Response__destroy(msg: *mut nav_msgs__srv__SetMap_Response);
    pub fn nav_msgs__srv__SetMap_Response__Sequence__init(
        array: *mut nav_msgs__srv__SetMap_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn nav_msgs__srv__SetMap_Response__Sequence__fini(
        array: *mut nav_msgs__srv__SetMap_Response__Sequence,
    );
    pub fn nav_msgs__srv__SetMap_Response__Sequence__create(
        size: usize,
    ) -> *mut nav_msgs__srv__SetMap_Response__Sequence;
    pub fn nav_msgs__srv__SetMap_Response__Sequence__destroy(
        array: *mut nav_msgs__srv__SetMap_Response__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__nav_msgs__srv__SetMap_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__nav_msgs__srv__SetMap_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__nav_msgs__srv__SetMap(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__rcl_interfaces__msg__FloatingPointRange(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__rcl_interfaces__msg__IntegerRange(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__rcl_interfaces__msg__ListParametersResult(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__rcl_interfaces__msg__Log(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__rcl_interfaces__msg__Parameter(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__rcl_interfaces__msg__ParameterDescriptor(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__rcl_interfaces__msg__ParameterEvent(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__rcl_interfaces__msg__ParameterEventDescriptors(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__rcl_interfaces__msg__ParameterType(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__rcl_interfaces__msg__ParameterValue(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__rcl_interfaces__msg__SetParametersResult(
    ) -> *const rosidl_message_type_support_t;
    pub fn rcl_interfaces__msg__FloatingPointRange__create(
    ) -> *mut rcl_interfaces__msg__FloatingPointRange;
    pub fn rcl_interfaces__msg__FloatingPointRange__destroy(
        msg: *mut rcl_interfaces__msg__FloatingPointRange,
    );
    pub fn rcl_interfaces__msg__FloatingPointRange__Sequence__init(
        array: *mut rcl_interfaces__msg__FloatingPointRange__Sequence,
        size: usize,
    ) -> bool;
    pub fn rcl_interfaces__msg__FloatingPointRange__Sequence__fini(
        array: *mut rcl_interfaces__msg__FloatingPointRange__Sequence,
    );
    pub fn rcl_interfaces__msg__FloatingPointRange__Sequence__create(
        size: usize,
    ) -> *mut rcl_interfaces__msg__FloatingPointRange__Sequence;
    pub fn rcl_interfaces__msg__FloatingPointRange__Sequence__destroy(
        array: *mut rcl_interfaces__msg__FloatingPointRange__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__FloatingPointRange(
    ) -> *const rosidl_message_type_support_t;
    pub fn rcl_interfaces__msg__IntegerRange__create() -> *mut rcl_interfaces__msg__IntegerRange;
    pub fn rcl_interfaces__msg__IntegerRange__destroy(msg: *mut rcl_interfaces__msg__IntegerRange);
    pub fn rcl_interfaces__msg__IntegerRange__Sequence__init(
        array: *mut rcl_interfaces__msg__IntegerRange__Sequence,
        size: usize,
    ) -> bool;
    pub fn rcl_interfaces__msg__IntegerRange__Sequence__fini(
        array: *mut rcl_interfaces__msg__IntegerRange__Sequence,
    );
    pub fn rcl_interfaces__msg__IntegerRange__Sequence__create(
        size: usize,
    ) -> *mut rcl_interfaces__msg__IntegerRange__Sequence;
    pub fn rcl_interfaces__msg__IntegerRange__Sequence__destroy(
        array: *mut rcl_interfaces__msg__IntegerRange__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__IntegerRange(
    ) -> *const rosidl_message_type_support_t;
    pub fn rcl_interfaces__msg__ListParametersResult__create(
    ) -> *mut rcl_interfaces__msg__ListParametersResult;
    pub fn rcl_interfaces__msg__ListParametersResult__destroy(
        msg: *mut rcl_interfaces__msg__ListParametersResult,
    );
    pub fn rcl_interfaces__msg__ListParametersResult__Sequence__init(
        array: *mut rcl_interfaces__msg__ListParametersResult__Sequence,
        size: usize,
    ) -> bool;
    pub fn rcl_interfaces__msg__ListParametersResult__Sequence__fini(
        array: *mut rcl_interfaces__msg__ListParametersResult__Sequence,
    );
    pub fn rcl_interfaces__msg__ListParametersResult__Sequence__create(
        size: usize,
    ) -> *mut rcl_interfaces__msg__ListParametersResult__Sequence;
    pub fn rcl_interfaces__msg__ListParametersResult__Sequence__destroy(
        array: *mut rcl_interfaces__msg__ListParametersResult__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__ListParametersResult(
    ) -> *const rosidl_message_type_support_t;
    pub fn rcl_interfaces__msg__Log__create() -> *mut rcl_interfaces__msg__Log;
    pub fn rcl_interfaces__msg__Log__destroy(msg: *mut rcl_interfaces__msg__Log);
    pub fn rcl_interfaces__msg__Log__Sequence__init(
        array: *mut rcl_interfaces__msg__Log__Sequence,
        size: usize,
    ) -> bool;
    pub fn rcl_interfaces__msg__Log__Sequence__fini(array: *mut rcl_interfaces__msg__Log__Sequence);
    pub fn rcl_interfaces__msg__Log__Sequence__create(
        size: usize,
    ) -> *mut rcl_interfaces__msg__Log__Sequence;
    pub fn rcl_interfaces__msg__Log__Sequence__destroy(
        array: *mut rcl_interfaces__msg__Log__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__Log(
    ) -> *const rosidl_message_type_support_t;
    pub fn rcl_interfaces__msg__Parameter__create() -> *mut rcl_interfaces__msg__Parameter;
    pub fn rcl_interfaces__msg__Parameter__destroy(msg: *mut rcl_interfaces__msg__Parameter);
    pub fn rcl_interfaces__msg__Parameter__Sequence__init(
        array: *mut rcl_interfaces__msg__Parameter__Sequence,
        size: usize,
    ) -> bool;
    pub fn rcl_interfaces__msg__Parameter__Sequence__fini(
        array: *mut rcl_interfaces__msg__Parameter__Sequence,
    );
    pub fn rcl_interfaces__msg__Parameter__Sequence__create(
        size: usize,
    ) -> *mut rcl_interfaces__msg__Parameter__Sequence;
    pub fn rcl_interfaces__msg__Parameter__Sequence__destroy(
        array: *mut rcl_interfaces__msg__Parameter__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__Parameter(
    ) -> *const rosidl_message_type_support_t;
    pub fn rcl_interfaces__msg__ParameterDescriptor__create(
    ) -> *mut rcl_interfaces__msg__ParameterDescriptor;
    pub fn rcl_interfaces__msg__ParameterDescriptor__destroy(
        msg: *mut rcl_interfaces__msg__ParameterDescriptor,
    );
    pub fn rcl_interfaces__msg__ParameterDescriptor__Sequence__init(
        array: *mut rcl_interfaces__msg__ParameterDescriptor__Sequence,
        size: usize,
    ) -> bool;
    pub fn rcl_interfaces__msg__ParameterDescriptor__Sequence__fini(
        array: *mut rcl_interfaces__msg__ParameterDescriptor__Sequence,
    );
    pub fn rcl_interfaces__msg__ParameterDescriptor__Sequence__create(
        size: usize,
    ) -> *mut rcl_interfaces__msg__ParameterDescriptor__Sequence;
    pub fn rcl_interfaces__msg__ParameterDescriptor__Sequence__destroy(
        array: *mut rcl_interfaces__msg__ParameterDescriptor__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__ParameterDescriptor(
    ) -> *const rosidl_message_type_support_t;
    pub fn rcl_interfaces__msg__ParameterEvent__create() -> *mut rcl_interfaces__msg__ParameterEvent;
    pub fn rcl_interfaces__msg__ParameterEvent__destroy(
        msg: *mut rcl_interfaces__msg__ParameterEvent,
    );
    pub fn rcl_interfaces__msg__ParameterEvent__Sequence__init(
        array: *mut rcl_interfaces__msg__ParameterEvent__Sequence,
        size: usize,
    ) -> bool;
    pub fn rcl_interfaces__msg__ParameterEvent__Sequence__fini(
        array: *mut rcl_interfaces__msg__ParameterEvent__Sequence,
    );
    pub fn rcl_interfaces__msg__ParameterEvent__Sequence__create(
        size: usize,
    ) -> *mut rcl_interfaces__msg__ParameterEvent__Sequence;
    pub fn rcl_interfaces__msg__ParameterEvent__Sequence__destroy(
        array: *mut rcl_interfaces__msg__ParameterEvent__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__ParameterEvent(
    ) -> *const rosidl_message_type_support_t;
    pub fn rcl_interfaces__msg__ParameterEventDescriptors__create(
    ) -> *mut rcl_interfaces__msg__ParameterEventDescriptors;
    pub fn rcl_interfaces__msg__ParameterEventDescriptors__destroy(
        msg: *mut rcl_interfaces__msg__ParameterEventDescriptors,
    );
    pub fn rcl_interfaces__msg__ParameterEventDescriptors__Sequence__init(
        array: *mut rcl_interfaces__msg__ParameterEventDescriptors__Sequence,
        size: usize,
    ) -> bool;
    pub fn rcl_interfaces__msg__ParameterEventDescriptors__Sequence__fini(
        array: *mut rcl_interfaces__msg__ParameterEventDescriptors__Sequence,
    );
    pub fn rcl_interfaces__msg__ParameterEventDescriptors__Sequence__create(
        size: usize,
    ) -> *mut rcl_interfaces__msg__ParameterEventDescriptors__Sequence;
    pub fn rcl_interfaces__msg__ParameterEventDescriptors__Sequence__destroy(
        array: *mut rcl_interfaces__msg__ParameterEventDescriptors__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__ParameterEventDescriptors(
    ) -> *const rosidl_message_type_support_t;
    pub fn rcl_interfaces__msg__ParameterType__create() -> *mut rcl_interfaces__msg__ParameterType;
    pub fn rcl_interfaces__msg__ParameterType__destroy(
        msg: *mut rcl_interfaces__msg__ParameterType,
    );
    pub fn rcl_interfaces__msg__ParameterType__Sequence__init(
        array: *mut rcl_interfaces__msg__ParameterType__Sequence,
        size: usize,
    ) -> bool;
    pub fn rcl_interfaces__msg__ParameterType__Sequence__fini(
        array: *mut rcl_interfaces__msg__ParameterType__Sequence,
    );
    pub fn rcl_interfaces__msg__ParameterType__Sequence__create(
        size: usize,
    ) -> *mut rcl_interfaces__msg__ParameterType__Sequence;
    pub fn rcl_interfaces__msg__ParameterType__Sequence__destroy(
        array: *mut rcl_interfaces__msg__ParameterType__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__ParameterType(
    ) -> *const rosidl_message_type_support_t;
    pub fn rcl_interfaces__msg__ParameterValue__create() -> *mut rcl_interfaces__msg__ParameterValue;
    pub fn rcl_interfaces__msg__ParameterValue__destroy(
        msg: *mut rcl_interfaces__msg__ParameterValue,
    );
    pub fn rcl_interfaces__msg__ParameterValue__Sequence__init(
        array: *mut rcl_interfaces__msg__ParameterValue__Sequence,
        size: usize,
    ) -> bool;
    pub fn rcl_interfaces__msg__ParameterValue__Sequence__fini(
        array: *mut rcl_interfaces__msg__ParameterValue__Sequence,
    );
    pub fn rcl_interfaces__msg__ParameterValue__Sequence__create(
        size: usize,
    ) -> *mut rcl_interfaces__msg__ParameterValue__Sequence;
    pub fn rcl_interfaces__msg__ParameterValue__Sequence__destroy(
        array: *mut rcl_interfaces__msg__ParameterValue__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__ParameterValue(
    ) -> *const rosidl_message_type_support_t;
    pub fn rcl_interfaces__msg__SetParametersResult__create(
    ) -> *mut rcl_interfaces__msg__SetParametersResult;
    pub fn rcl_interfaces__msg__SetParametersResult__destroy(
        msg: *mut rcl_interfaces__msg__SetParametersResult,
    );
    pub fn rcl_interfaces__msg__SetParametersResult__Sequence__init(
        array: *mut rcl_interfaces__msg__SetParametersResult__Sequence,
        size: usize,
    ) -> bool;
    pub fn rcl_interfaces__msg__SetParametersResult__Sequence__fini(
        array: *mut rcl_interfaces__msg__SetParametersResult__Sequence,
    );
    pub fn rcl_interfaces__msg__SetParametersResult__Sequence__create(
        size: usize,
    ) -> *mut rcl_interfaces__msg__SetParametersResult__Sequence;
    pub fn rcl_interfaces__msg__SetParametersResult__Sequence__destroy(
        array: *mut rcl_interfaces__msg__SetParametersResult__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__msg__SetParametersResult(
    ) -> *const rosidl_message_type_support_t;
    pub fn rcl_interfaces__srv__DescribeParameters_Request__create(
    ) -> *mut rcl_interfaces__srv__DescribeParameters_Request;
    pub fn rcl_interfaces__srv__DescribeParameters_Request__destroy(
        msg: *mut rcl_interfaces__srv__DescribeParameters_Request,
    );
    pub fn rcl_interfaces__srv__DescribeParameters_Request__Sequence__init(
        array: *mut rcl_interfaces__srv__DescribeParameters_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn rcl_interfaces__srv__DescribeParameters_Request__Sequence__fini(
        array: *mut rcl_interfaces__srv__DescribeParameters_Request__Sequence,
    );
    pub fn rcl_interfaces__srv__DescribeParameters_Request__Sequence__create(
        size: usize,
    ) -> *mut rcl_interfaces__srv__DescribeParameters_Request__Sequence;
    pub fn rcl_interfaces__srv__DescribeParameters_Request__Sequence__destroy(
        array: *mut rcl_interfaces__srv__DescribeParameters_Request__Sequence,
    );
    pub fn rcl_interfaces__srv__DescribeParameters_Response__create(
    ) -> *mut rcl_interfaces__srv__DescribeParameters_Response;
    pub fn rcl_interfaces__srv__DescribeParameters_Response__destroy(
        msg: *mut rcl_interfaces__srv__DescribeParameters_Response,
    );
    pub fn rcl_interfaces__srv__DescribeParameters_Response__Sequence__init(
        array: *mut rcl_interfaces__srv__DescribeParameters_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn rcl_interfaces__srv__DescribeParameters_Response__Sequence__fini(
        array: *mut rcl_interfaces__srv__DescribeParameters_Response__Sequence,
    );
    pub fn rcl_interfaces__srv__DescribeParameters_Response__Sequence__create(
        size: usize,
    ) -> *mut rcl_interfaces__srv__DescribeParameters_Response__Sequence;
    pub fn rcl_interfaces__srv__DescribeParameters_Response__Sequence__destroy(
        array: *mut rcl_interfaces__srv__DescribeParameters_Response__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__srv__DescribeParameters_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__srv__DescribeParameters_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__rcl_interfaces__srv__DescribeParameters(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__rcl_interfaces__srv__DescribeParameters_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__rcl_interfaces__srv__DescribeParameters_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__rcl_interfaces__srv__DescribeParameters(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__rcl_interfaces__srv__GetParameterTypes_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__rcl_interfaces__srv__GetParameterTypes_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__rcl_interfaces__srv__GetParameterTypes(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__rcl_interfaces__srv__GetParameters_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__rcl_interfaces__srv__GetParameters_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__rcl_interfaces__srv__GetParameters(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__rcl_interfaces__srv__ListParameters_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__rcl_interfaces__srv__ListParameters_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__rcl_interfaces__srv__ListParameters(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__rcl_interfaces__srv__SetParameters_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__rcl_interfaces__srv__SetParameters_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__rcl_interfaces__srv__SetParameters(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__rcl_interfaces__srv__SetParametersAtomically_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__rcl_interfaces__srv__SetParametersAtomically_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__rcl_interfaces__srv__SetParametersAtomically(
    ) -> *const rosidl_service_type_support_t;
    pub fn rcl_interfaces__srv__GetParameterTypes_Request__create(
    ) -> *mut rcl_interfaces__srv__GetParameterTypes_Request;
    pub fn rcl_interfaces__srv__GetParameterTypes_Request__destroy(
        msg: *mut rcl_interfaces__srv__GetParameterTypes_Request,
    );
    pub fn rcl_interfaces__srv__GetParameterTypes_Request__Sequence__init(
        array: *mut rcl_interfaces__srv__GetParameterTypes_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn rcl_interfaces__srv__GetParameterTypes_Request__Sequence__fini(
        array: *mut rcl_interfaces__srv__GetParameterTypes_Request__Sequence,
    );
    pub fn rcl_interfaces__srv__GetParameterTypes_Request__Sequence__create(
        size: usize,
    ) -> *mut rcl_interfaces__srv__GetParameterTypes_Request__Sequence;
    pub fn rcl_interfaces__srv__GetParameterTypes_Request__Sequence__destroy(
        array: *mut rcl_interfaces__srv__GetParameterTypes_Request__Sequence,
    );
    pub fn rcl_interfaces__srv__GetParameterTypes_Response__create(
    ) -> *mut rcl_interfaces__srv__GetParameterTypes_Response;
    pub fn rcl_interfaces__srv__GetParameterTypes_Response__destroy(
        msg: *mut rcl_interfaces__srv__GetParameterTypes_Response,
    );
    pub fn rcl_interfaces__srv__GetParameterTypes_Response__Sequence__init(
        array: *mut rcl_interfaces__srv__GetParameterTypes_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn rcl_interfaces__srv__GetParameterTypes_Response__Sequence__fini(
        array: *mut rcl_interfaces__srv__GetParameterTypes_Response__Sequence,
    );
    pub fn rcl_interfaces__srv__GetParameterTypes_Response__Sequence__create(
        size: usize,
    ) -> *mut rcl_interfaces__srv__GetParameterTypes_Response__Sequence;
    pub fn rcl_interfaces__srv__GetParameterTypes_Response__Sequence__destroy(
        array: *mut rcl_interfaces__srv__GetParameterTypes_Response__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__srv__GetParameterTypes_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__srv__GetParameterTypes_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__rcl_interfaces__srv__GetParameterTypes(
    ) -> *const rosidl_service_type_support_t;
    pub fn rcl_interfaces__srv__GetParameters_Request__create(
    ) -> *mut rcl_interfaces__srv__GetParameters_Request;
    pub fn rcl_interfaces__srv__GetParameters_Request__destroy(
        msg: *mut rcl_interfaces__srv__GetParameters_Request,
    );
    pub fn rcl_interfaces__srv__GetParameters_Request__Sequence__init(
        array: *mut rcl_interfaces__srv__GetParameters_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn rcl_interfaces__srv__GetParameters_Request__Sequence__fini(
        array: *mut rcl_interfaces__srv__GetParameters_Request__Sequence,
    );
    pub fn rcl_interfaces__srv__GetParameters_Request__Sequence__create(
        size: usize,
    ) -> *mut rcl_interfaces__srv__GetParameters_Request__Sequence;
    pub fn rcl_interfaces__srv__GetParameters_Request__Sequence__destroy(
        array: *mut rcl_interfaces__srv__GetParameters_Request__Sequence,
    );
    pub fn rcl_interfaces__srv__GetParameters_Response__create(
    ) -> *mut rcl_interfaces__srv__GetParameters_Response;
    pub fn rcl_interfaces__srv__GetParameters_Response__destroy(
        msg: *mut rcl_interfaces__srv__GetParameters_Response,
    );
    pub fn rcl_interfaces__srv__GetParameters_Response__Sequence__init(
        array: *mut rcl_interfaces__srv__GetParameters_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn rcl_interfaces__srv__GetParameters_Response__Sequence__fini(
        array: *mut rcl_interfaces__srv__GetParameters_Response__Sequence,
    );
    pub fn rcl_interfaces__srv__GetParameters_Response__Sequence__create(
        size: usize,
    ) -> *mut rcl_interfaces__srv__GetParameters_Response__Sequence;
    pub fn rcl_interfaces__srv__GetParameters_Response__Sequence__destroy(
        array: *mut rcl_interfaces__srv__GetParameters_Response__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__srv__GetParameters_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__srv__GetParameters_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__rcl_interfaces__srv__GetParameters(
    ) -> *const rosidl_service_type_support_t;
    pub fn rcl_interfaces__srv__ListParameters_Request__create(
    ) -> *mut rcl_interfaces__srv__ListParameters_Request;
    pub fn rcl_interfaces__srv__ListParameters_Request__destroy(
        msg: *mut rcl_interfaces__srv__ListParameters_Request,
    );
    pub fn rcl_interfaces__srv__ListParameters_Request__Sequence__init(
        array: *mut rcl_interfaces__srv__ListParameters_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn rcl_interfaces__srv__ListParameters_Request__Sequence__fini(
        array: *mut rcl_interfaces__srv__ListParameters_Request__Sequence,
    );
    pub fn rcl_interfaces__srv__ListParameters_Request__Sequence__create(
        size: usize,
    ) -> *mut rcl_interfaces__srv__ListParameters_Request__Sequence;
    pub fn rcl_interfaces__srv__ListParameters_Request__Sequence__destroy(
        array: *mut rcl_interfaces__srv__ListParameters_Request__Sequence,
    );
    pub fn rcl_interfaces__srv__ListParameters_Response__create(
    ) -> *mut rcl_interfaces__srv__ListParameters_Response;
    pub fn rcl_interfaces__srv__ListParameters_Response__destroy(
        msg: *mut rcl_interfaces__srv__ListParameters_Response,
    );
    pub fn rcl_interfaces__srv__ListParameters_Response__Sequence__init(
        array: *mut rcl_interfaces__srv__ListParameters_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn rcl_interfaces__srv__ListParameters_Response__Sequence__fini(
        array: *mut rcl_interfaces__srv__ListParameters_Response__Sequence,
    );
    pub fn rcl_interfaces__srv__ListParameters_Response__Sequence__create(
        size: usize,
    ) -> *mut rcl_interfaces__srv__ListParameters_Response__Sequence;
    pub fn rcl_interfaces__srv__ListParameters_Response__Sequence__destroy(
        array: *mut rcl_interfaces__srv__ListParameters_Response__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__srv__ListParameters_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__srv__ListParameters_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__rcl_interfaces__srv__ListParameters(
    ) -> *const rosidl_service_type_support_t;
    pub fn rcl_interfaces__srv__SetParameters_Request__create(
    ) -> *mut rcl_interfaces__srv__SetParameters_Request;
    pub fn rcl_interfaces__srv__SetParameters_Request__destroy(
        msg: *mut rcl_interfaces__srv__SetParameters_Request,
    );
    pub fn rcl_interfaces__srv__SetParameters_Request__Sequence__init(
        array: *mut rcl_interfaces__srv__SetParameters_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn rcl_interfaces__srv__SetParameters_Request__Sequence__fini(
        array: *mut rcl_interfaces__srv__SetParameters_Request__Sequence,
    );
    pub fn rcl_interfaces__srv__SetParameters_Request__Sequence__create(
        size: usize,
    ) -> *mut rcl_interfaces__srv__SetParameters_Request__Sequence;
    pub fn rcl_interfaces__srv__SetParameters_Request__Sequence__destroy(
        array: *mut rcl_interfaces__srv__SetParameters_Request__Sequence,
    );
    pub fn rcl_interfaces__srv__SetParameters_Response__create(
    ) -> *mut rcl_interfaces__srv__SetParameters_Response;
    pub fn rcl_interfaces__srv__SetParameters_Response__destroy(
        msg: *mut rcl_interfaces__srv__SetParameters_Response,
    );
    pub fn rcl_interfaces__srv__SetParameters_Response__Sequence__init(
        array: *mut rcl_interfaces__srv__SetParameters_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn rcl_interfaces__srv__SetParameters_Response__Sequence__fini(
        array: *mut rcl_interfaces__srv__SetParameters_Response__Sequence,
    );
    pub fn rcl_interfaces__srv__SetParameters_Response__Sequence__create(
        size: usize,
    ) -> *mut rcl_interfaces__srv__SetParameters_Response__Sequence;
    pub fn rcl_interfaces__srv__SetParameters_Response__Sequence__destroy(
        array: *mut rcl_interfaces__srv__SetParameters_Response__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__srv__SetParameters_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__srv__SetParameters_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__rcl_interfaces__srv__SetParameters(
    ) -> *const rosidl_service_type_support_t;
    pub fn rcl_interfaces__srv__SetParametersAtomically_Request__create(
    ) -> *mut rcl_interfaces__srv__SetParametersAtomically_Request;
    pub fn rcl_interfaces__srv__SetParametersAtomically_Request__destroy(
        msg: *mut rcl_interfaces__srv__SetParametersAtomically_Request,
    );
    pub fn rcl_interfaces__srv__SetParametersAtomically_Request__Sequence__init(
        array: *mut rcl_interfaces__srv__SetParametersAtomically_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn rcl_interfaces__srv__SetParametersAtomically_Request__Sequence__fini(
        array: *mut rcl_interfaces__srv__SetParametersAtomically_Request__Sequence,
    );
    pub fn rcl_interfaces__srv__SetParametersAtomically_Request__Sequence__create(
        size: usize,
    ) -> *mut rcl_interfaces__srv__SetParametersAtomically_Request__Sequence;
    pub fn rcl_interfaces__srv__SetParametersAtomically_Request__Sequence__destroy(
        array: *mut rcl_interfaces__srv__SetParametersAtomically_Request__Sequence,
    );
    pub fn rcl_interfaces__srv__SetParametersAtomically_Response__create(
    ) -> *mut rcl_interfaces__srv__SetParametersAtomically_Response;
    pub fn rcl_interfaces__srv__SetParametersAtomically_Response__destroy(
        msg: *mut rcl_interfaces__srv__SetParametersAtomically_Response,
    );
    pub fn rcl_interfaces__srv__SetParametersAtomically_Response__Sequence__init(
        array: *mut rcl_interfaces__srv__SetParametersAtomically_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn rcl_interfaces__srv__SetParametersAtomically_Response__Sequence__fini(
        array: *mut rcl_interfaces__srv__SetParametersAtomically_Response__Sequence,
    );
    pub fn rcl_interfaces__srv__SetParametersAtomically_Response__Sequence__create(
        size: usize,
    ) -> *mut rcl_interfaces__srv__SetParametersAtomically_Response__Sequence;
    pub fn rcl_interfaces__srv__SetParametersAtomically_Response__Sequence__destroy(
        array: *mut rcl_interfaces__srv__SetParametersAtomically_Response__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__srv__SetParametersAtomically_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__rcl_interfaces__srv__SetParametersAtomically_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__rcl_interfaces__srv__SetParametersAtomically(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosgraph_msgs__msg__Clock__create() -> *mut rosgraph_msgs__msg__Clock;
    pub fn rosgraph_msgs__msg__Clock__destroy(msg: *mut rosgraph_msgs__msg__Clock);
    pub fn rosgraph_msgs__msg__Clock__Sequence__init(
        array: *mut rosgraph_msgs__msg__Clock__Sequence,
        size: usize,
    ) -> bool;
    pub fn rosgraph_msgs__msg__Clock__Sequence__fini(
        array: *mut rosgraph_msgs__msg__Clock__Sequence,
    );
    pub fn rosgraph_msgs__msg__Clock__Sequence__create(
        size: usize,
    ) -> *mut rosgraph_msgs__msg__Clock__Sequence;
    pub fn rosgraph_msgs__msg__Clock__Sequence__destroy(
        array: *mut rosgraph_msgs__msg__Clock__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__rosgraph_msgs__msg__Clock(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__rosgraph_msgs__msg__Clock(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__BatteryState__create() -> *mut sensor_msgs__msg__BatteryState;
    pub fn sensor_msgs__msg__BatteryState__destroy(msg: *mut sensor_msgs__msg__BatteryState);
    pub fn sensor_msgs__msg__BatteryState__Sequence__init(
        array: *mut sensor_msgs__msg__BatteryState__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__BatteryState__Sequence__fini(
        array: *mut sensor_msgs__msg__BatteryState__Sequence,
    );
    pub fn sensor_msgs__msg__BatteryState__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__BatteryState__Sequence;
    pub fn sensor_msgs__msg__BatteryState__Sequence__destroy(
        array: *mut sensor_msgs__msg__BatteryState__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__BatteryState(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__CameraInfo__create() -> *mut sensor_msgs__msg__CameraInfo;
    pub fn sensor_msgs__msg__CameraInfo__destroy(msg: *mut sensor_msgs__msg__CameraInfo);
    pub fn sensor_msgs__msg__CameraInfo__Sequence__init(
        array: *mut sensor_msgs__msg__CameraInfo__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__CameraInfo__Sequence__fini(
        array: *mut sensor_msgs__msg__CameraInfo__Sequence,
    );
    pub fn sensor_msgs__msg__CameraInfo__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__CameraInfo__Sequence;
    pub fn sensor_msgs__msg__CameraInfo__Sequence__destroy(
        array: *mut sensor_msgs__msg__CameraInfo__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__CameraInfo(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__ChannelFloat32__create() -> *mut sensor_msgs__msg__ChannelFloat32;
    pub fn sensor_msgs__msg__ChannelFloat32__destroy(msg: *mut sensor_msgs__msg__ChannelFloat32);
    pub fn sensor_msgs__msg__ChannelFloat32__Sequence__init(
        array: *mut sensor_msgs__msg__ChannelFloat32__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__ChannelFloat32__Sequence__fini(
        array: *mut sensor_msgs__msg__ChannelFloat32__Sequence,
    );
    pub fn sensor_msgs__msg__ChannelFloat32__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__ChannelFloat32__Sequence;
    pub fn sensor_msgs__msg__ChannelFloat32__Sequence__destroy(
        array: *mut sensor_msgs__msg__ChannelFloat32__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__ChannelFloat32(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__CompressedImage__create() -> *mut sensor_msgs__msg__CompressedImage;
    pub fn sensor_msgs__msg__CompressedImage__destroy(msg: *mut sensor_msgs__msg__CompressedImage);
    pub fn sensor_msgs__msg__CompressedImage__Sequence__init(
        array: *mut sensor_msgs__msg__CompressedImage__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__CompressedImage__Sequence__fini(
        array: *mut sensor_msgs__msg__CompressedImage__Sequence,
    );
    pub fn sensor_msgs__msg__CompressedImage__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__CompressedImage__Sequence;
    pub fn sensor_msgs__msg__CompressedImage__Sequence__destroy(
        array: *mut sensor_msgs__msg__CompressedImage__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__CompressedImage(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__BatteryState(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__CameraInfo(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__ChannelFloat32(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__CompressedImage(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__FluidPressure(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__Illuminance(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__Image(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__Imu(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__JointState(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__Joy(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__JoyFeedback(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__JoyFeedbackArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__LaserEcho(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__LaserScan(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__MagneticField(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__MultiDOFJointState(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__MultiEchoLaserScan(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__NavSatFix(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__NavSatStatus(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__PointCloud2(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__PointCloud(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__PointField(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__Range(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__RegionOfInterest(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__RelativeHumidity(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__Temperature(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__msg__TimeReference(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__FluidPressure__create() -> *mut sensor_msgs__msg__FluidPressure;
    pub fn sensor_msgs__msg__FluidPressure__destroy(msg: *mut sensor_msgs__msg__FluidPressure);
    pub fn sensor_msgs__msg__FluidPressure__Sequence__init(
        array: *mut sensor_msgs__msg__FluidPressure__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__FluidPressure__Sequence__fini(
        array: *mut sensor_msgs__msg__FluidPressure__Sequence,
    );
    pub fn sensor_msgs__msg__FluidPressure__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__FluidPressure__Sequence;
    pub fn sensor_msgs__msg__FluidPressure__Sequence__destroy(
        array: *mut sensor_msgs__msg__FluidPressure__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__FluidPressure(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__Illuminance__create() -> *mut sensor_msgs__msg__Illuminance;
    pub fn sensor_msgs__msg__Illuminance__destroy(msg: *mut sensor_msgs__msg__Illuminance);
    pub fn sensor_msgs__msg__Illuminance__Sequence__init(
        array: *mut sensor_msgs__msg__Illuminance__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__Illuminance__Sequence__fini(
        array: *mut sensor_msgs__msg__Illuminance__Sequence,
    );
    pub fn sensor_msgs__msg__Illuminance__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__Illuminance__Sequence;
    pub fn sensor_msgs__msg__Illuminance__Sequence__destroy(
        array: *mut sensor_msgs__msg__Illuminance__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__Illuminance(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__Image__create() -> *mut sensor_msgs__msg__Image;
    pub fn sensor_msgs__msg__Image__destroy(msg: *mut sensor_msgs__msg__Image);
    pub fn sensor_msgs__msg__Image__Sequence__init(
        array: *mut sensor_msgs__msg__Image__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__Image__Sequence__fini(array: *mut sensor_msgs__msg__Image__Sequence);
    pub fn sensor_msgs__msg__Image__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__Image__Sequence;
    pub fn sensor_msgs__msg__Image__Sequence__destroy(
        array: *mut sensor_msgs__msg__Image__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__Image(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__Imu__create() -> *mut sensor_msgs__msg__Imu;
    pub fn sensor_msgs__msg__Imu__destroy(msg: *mut sensor_msgs__msg__Imu);
    pub fn sensor_msgs__msg__Imu__Sequence__init(
        array: *mut sensor_msgs__msg__Imu__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__Imu__Sequence__fini(array: *mut sensor_msgs__msg__Imu__Sequence);
    pub fn sensor_msgs__msg__Imu__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__Imu__Sequence;
    pub fn sensor_msgs__msg__Imu__Sequence__destroy(array: *mut sensor_msgs__msg__Imu__Sequence);
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__Imu(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__JointState__create() -> *mut sensor_msgs__msg__JointState;
    pub fn sensor_msgs__msg__JointState__destroy(msg: *mut sensor_msgs__msg__JointState);
    pub fn sensor_msgs__msg__JointState__Sequence__init(
        array: *mut sensor_msgs__msg__JointState__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__JointState__Sequence__fini(
        array: *mut sensor_msgs__msg__JointState__Sequence,
    );
    pub fn sensor_msgs__msg__JointState__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__JointState__Sequence;
    pub fn sensor_msgs__msg__JointState__Sequence__destroy(
        array: *mut sensor_msgs__msg__JointState__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__JointState(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__Joy__create() -> *mut sensor_msgs__msg__Joy;
    pub fn sensor_msgs__msg__Joy__destroy(msg: *mut sensor_msgs__msg__Joy);
    pub fn sensor_msgs__msg__Joy__Sequence__init(
        array: *mut sensor_msgs__msg__Joy__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__Joy__Sequence__fini(array: *mut sensor_msgs__msg__Joy__Sequence);
    pub fn sensor_msgs__msg__Joy__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__Joy__Sequence;
    pub fn sensor_msgs__msg__Joy__Sequence__destroy(array: *mut sensor_msgs__msg__Joy__Sequence);
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__Joy(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__JoyFeedback__create() -> *mut sensor_msgs__msg__JoyFeedback;
    pub fn sensor_msgs__msg__JoyFeedback__destroy(msg: *mut sensor_msgs__msg__JoyFeedback);
    pub fn sensor_msgs__msg__JoyFeedback__Sequence__init(
        array: *mut sensor_msgs__msg__JoyFeedback__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__JoyFeedback__Sequence__fini(
        array: *mut sensor_msgs__msg__JoyFeedback__Sequence,
    );
    pub fn sensor_msgs__msg__JoyFeedback__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__JoyFeedback__Sequence;
    pub fn sensor_msgs__msg__JoyFeedback__Sequence__destroy(
        array: *mut sensor_msgs__msg__JoyFeedback__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__JoyFeedback(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__JoyFeedbackArray__create() -> *mut sensor_msgs__msg__JoyFeedbackArray;
    pub fn sensor_msgs__msg__JoyFeedbackArray__destroy(
        msg: *mut sensor_msgs__msg__JoyFeedbackArray,
    );
    pub fn sensor_msgs__msg__JoyFeedbackArray__Sequence__init(
        array: *mut sensor_msgs__msg__JoyFeedbackArray__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__JoyFeedbackArray__Sequence__fini(
        array: *mut sensor_msgs__msg__JoyFeedbackArray__Sequence,
    );
    pub fn sensor_msgs__msg__JoyFeedbackArray__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__JoyFeedbackArray__Sequence;
    pub fn sensor_msgs__msg__JoyFeedbackArray__Sequence__destroy(
        array: *mut sensor_msgs__msg__JoyFeedbackArray__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__JoyFeedbackArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__LaserEcho__create() -> *mut sensor_msgs__msg__LaserEcho;
    pub fn sensor_msgs__msg__LaserEcho__destroy(msg: *mut sensor_msgs__msg__LaserEcho);
    pub fn sensor_msgs__msg__LaserEcho__Sequence__init(
        array: *mut sensor_msgs__msg__LaserEcho__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__LaserEcho__Sequence__fini(
        array: *mut sensor_msgs__msg__LaserEcho__Sequence,
    );
    pub fn sensor_msgs__msg__LaserEcho__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__LaserEcho__Sequence;
    pub fn sensor_msgs__msg__LaserEcho__Sequence__destroy(
        array: *mut sensor_msgs__msg__LaserEcho__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__LaserEcho(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__LaserScan__create() -> *mut sensor_msgs__msg__LaserScan;
    pub fn sensor_msgs__msg__LaserScan__destroy(msg: *mut sensor_msgs__msg__LaserScan);
    pub fn sensor_msgs__msg__LaserScan__Sequence__init(
        array: *mut sensor_msgs__msg__LaserScan__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__LaserScan__Sequence__fini(
        array: *mut sensor_msgs__msg__LaserScan__Sequence,
    );
    pub fn sensor_msgs__msg__LaserScan__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__LaserScan__Sequence;
    pub fn sensor_msgs__msg__LaserScan__Sequence__destroy(
        array: *mut sensor_msgs__msg__LaserScan__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__LaserScan(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__MagneticField__create() -> *mut sensor_msgs__msg__MagneticField;
    pub fn sensor_msgs__msg__MagneticField__destroy(msg: *mut sensor_msgs__msg__MagneticField);
    pub fn sensor_msgs__msg__MagneticField__Sequence__init(
        array: *mut sensor_msgs__msg__MagneticField__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__MagneticField__Sequence__fini(
        array: *mut sensor_msgs__msg__MagneticField__Sequence,
    );
    pub fn sensor_msgs__msg__MagneticField__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__MagneticField__Sequence;
    pub fn sensor_msgs__msg__MagneticField__Sequence__destroy(
        array: *mut sensor_msgs__msg__MagneticField__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__MagneticField(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__MultiDOFJointState__create(
    ) -> *mut sensor_msgs__msg__MultiDOFJointState;
    pub fn sensor_msgs__msg__MultiDOFJointState__destroy(
        msg: *mut sensor_msgs__msg__MultiDOFJointState,
    );
    pub fn sensor_msgs__msg__MultiDOFJointState__Sequence__init(
        array: *mut sensor_msgs__msg__MultiDOFJointState__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__MultiDOFJointState__Sequence__fini(
        array: *mut sensor_msgs__msg__MultiDOFJointState__Sequence,
    );
    pub fn sensor_msgs__msg__MultiDOFJointState__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__MultiDOFJointState__Sequence;
    pub fn sensor_msgs__msg__MultiDOFJointState__Sequence__destroy(
        array: *mut sensor_msgs__msg__MultiDOFJointState__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__MultiDOFJointState(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__MultiEchoLaserScan__create(
    ) -> *mut sensor_msgs__msg__MultiEchoLaserScan;
    pub fn sensor_msgs__msg__MultiEchoLaserScan__destroy(
        msg: *mut sensor_msgs__msg__MultiEchoLaserScan,
    );
    pub fn sensor_msgs__msg__MultiEchoLaserScan__Sequence__init(
        array: *mut sensor_msgs__msg__MultiEchoLaserScan__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__MultiEchoLaserScan__Sequence__fini(
        array: *mut sensor_msgs__msg__MultiEchoLaserScan__Sequence,
    );
    pub fn sensor_msgs__msg__MultiEchoLaserScan__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__MultiEchoLaserScan__Sequence;
    pub fn sensor_msgs__msg__MultiEchoLaserScan__Sequence__destroy(
        array: *mut sensor_msgs__msg__MultiEchoLaserScan__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__MultiEchoLaserScan(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__NavSatFix__create() -> *mut sensor_msgs__msg__NavSatFix;
    pub fn sensor_msgs__msg__NavSatFix__destroy(msg: *mut sensor_msgs__msg__NavSatFix);
    pub fn sensor_msgs__msg__NavSatFix__Sequence__init(
        array: *mut sensor_msgs__msg__NavSatFix__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__NavSatFix__Sequence__fini(
        array: *mut sensor_msgs__msg__NavSatFix__Sequence,
    );
    pub fn sensor_msgs__msg__NavSatFix__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__NavSatFix__Sequence;
    pub fn sensor_msgs__msg__NavSatFix__Sequence__destroy(
        array: *mut sensor_msgs__msg__NavSatFix__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__NavSatFix(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__NavSatStatus__create() -> *mut sensor_msgs__msg__NavSatStatus;
    pub fn sensor_msgs__msg__NavSatStatus__destroy(msg: *mut sensor_msgs__msg__NavSatStatus);
    pub fn sensor_msgs__msg__NavSatStatus__Sequence__init(
        array: *mut sensor_msgs__msg__NavSatStatus__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__NavSatStatus__Sequence__fini(
        array: *mut sensor_msgs__msg__NavSatStatus__Sequence,
    );
    pub fn sensor_msgs__msg__NavSatStatus__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__NavSatStatus__Sequence;
    pub fn sensor_msgs__msg__NavSatStatus__Sequence__destroy(
        array: *mut sensor_msgs__msg__NavSatStatus__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__NavSatStatus(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__PointCloud__create() -> *mut sensor_msgs__msg__PointCloud;
    pub fn sensor_msgs__msg__PointCloud__destroy(msg: *mut sensor_msgs__msg__PointCloud);
    pub fn sensor_msgs__msg__PointCloud__Sequence__init(
        array: *mut sensor_msgs__msg__PointCloud__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__PointCloud__Sequence__fini(
        array: *mut sensor_msgs__msg__PointCloud__Sequence,
    );
    pub fn sensor_msgs__msg__PointCloud__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__PointCloud__Sequence;
    pub fn sensor_msgs__msg__PointCloud__Sequence__destroy(
        array: *mut sensor_msgs__msg__PointCloud__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__PointCloud(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__PointCloud2__create() -> *mut sensor_msgs__msg__PointCloud2;
    pub fn sensor_msgs__msg__PointCloud2__destroy(msg: *mut sensor_msgs__msg__PointCloud2);
    pub fn sensor_msgs__msg__PointCloud2__Sequence__init(
        array: *mut sensor_msgs__msg__PointCloud2__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__PointCloud2__Sequence__fini(
        array: *mut sensor_msgs__msg__PointCloud2__Sequence,
    );
    pub fn sensor_msgs__msg__PointCloud2__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__PointCloud2__Sequence;
    pub fn sensor_msgs__msg__PointCloud2__Sequence__destroy(
        array: *mut sensor_msgs__msg__PointCloud2__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__PointCloud2(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__PointField__create() -> *mut sensor_msgs__msg__PointField;
    pub fn sensor_msgs__msg__PointField__destroy(msg: *mut sensor_msgs__msg__PointField);
    pub fn sensor_msgs__msg__PointField__Sequence__init(
        array: *mut sensor_msgs__msg__PointField__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__PointField__Sequence__fini(
        array: *mut sensor_msgs__msg__PointField__Sequence,
    );
    pub fn sensor_msgs__msg__PointField__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__PointField__Sequence;
    pub fn sensor_msgs__msg__PointField__Sequence__destroy(
        array: *mut sensor_msgs__msg__PointField__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__PointField(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__Range__create() -> *mut sensor_msgs__msg__Range;
    pub fn sensor_msgs__msg__Range__destroy(msg: *mut sensor_msgs__msg__Range);
    pub fn sensor_msgs__msg__Range__Sequence__init(
        array: *mut sensor_msgs__msg__Range__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__Range__Sequence__fini(array: *mut sensor_msgs__msg__Range__Sequence);
    pub fn sensor_msgs__msg__Range__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__Range__Sequence;
    pub fn sensor_msgs__msg__Range__Sequence__destroy(
        array: *mut sensor_msgs__msg__Range__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__Range(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__RegionOfInterest__create() -> *mut sensor_msgs__msg__RegionOfInterest;
    pub fn sensor_msgs__msg__RegionOfInterest__destroy(
        msg: *mut sensor_msgs__msg__RegionOfInterest,
    );
    pub fn sensor_msgs__msg__RegionOfInterest__Sequence__init(
        array: *mut sensor_msgs__msg__RegionOfInterest__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__RegionOfInterest__Sequence__fini(
        array: *mut sensor_msgs__msg__RegionOfInterest__Sequence,
    );
    pub fn sensor_msgs__msg__RegionOfInterest__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__RegionOfInterest__Sequence;
    pub fn sensor_msgs__msg__RegionOfInterest__Sequence__destroy(
        array: *mut sensor_msgs__msg__RegionOfInterest__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__RegionOfInterest(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__RelativeHumidity__create() -> *mut sensor_msgs__msg__RelativeHumidity;
    pub fn sensor_msgs__msg__RelativeHumidity__destroy(
        msg: *mut sensor_msgs__msg__RelativeHumidity,
    );
    pub fn sensor_msgs__msg__RelativeHumidity__Sequence__init(
        array: *mut sensor_msgs__msg__RelativeHumidity__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__RelativeHumidity__Sequence__fini(
        array: *mut sensor_msgs__msg__RelativeHumidity__Sequence,
    );
    pub fn sensor_msgs__msg__RelativeHumidity__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__RelativeHumidity__Sequence;
    pub fn sensor_msgs__msg__RelativeHumidity__Sequence__destroy(
        array: *mut sensor_msgs__msg__RelativeHumidity__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__RelativeHumidity(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__Temperature__create() -> *mut sensor_msgs__msg__Temperature;
    pub fn sensor_msgs__msg__Temperature__destroy(msg: *mut sensor_msgs__msg__Temperature);
    pub fn sensor_msgs__msg__Temperature__Sequence__init(
        array: *mut sensor_msgs__msg__Temperature__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__Temperature__Sequence__fini(
        array: *mut sensor_msgs__msg__Temperature__Sequence,
    );
    pub fn sensor_msgs__msg__Temperature__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__Temperature__Sequence;
    pub fn sensor_msgs__msg__Temperature__Sequence__destroy(
        array: *mut sensor_msgs__msg__Temperature__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__Temperature(
    ) -> *const rosidl_message_type_support_t;
    pub fn sensor_msgs__msg__TimeReference__create() -> *mut sensor_msgs__msg__TimeReference;
    pub fn sensor_msgs__msg__TimeReference__destroy(msg: *mut sensor_msgs__msg__TimeReference);
    pub fn sensor_msgs__msg__TimeReference__Sequence__init(
        array: *mut sensor_msgs__msg__TimeReference__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__msg__TimeReference__Sequence__fini(
        array: *mut sensor_msgs__msg__TimeReference__Sequence,
    );
    pub fn sensor_msgs__msg__TimeReference__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__msg__TimeReference__Sequence;
    pub fn sensor_msgs__msg__TimeReference__Sequence__destroy(
        array: *mut sensor_msgs__msg__TimeReference__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__msg__TimeReference(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__srv__SetCameraInfo_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__sensor_msgs__srv__SetCameraInfo_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__sensor_msgs__srv__SetCameraInfo(
    ) -> *const rosidl_service_type_support_t;
    pub fn sensor_msgs__srv__SetCameraInfo_Request__create(
    ) -> *mut sensor_msgs__srv__SetCameraInfo_Request;
    pub fn sensor_msgs__srv__SetCameraInfo_Request__destroy(
        msg: *mut sensor_msgs__srv__SetCameraInfo_Request,
    );
    pub fn sensor_msgs__srv__SetCameraInfo_Request__Sequence__init(
        array: *mut sensor_msgs__srv__SetCameraInfo_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__srv__SetCameraInfo_Request__Sequence__fini(
        array: *mut sensor_msgs__srv__SetCameraInfo_Request__Sequence,
    );
    pub fn sensor_msgs__srv__SetCameraInfo_Request__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__srv__SetCameraInfo_Request__Sequence;
    pub fn sensor_msgs__srv__SetCameraInfo_Request__Sequence__destroy(
        array: *mut sensor_msgs__srv__SetCameraInfo_Request__Sequence,
    );
    pub fn sensor_msgs__srv__SetCameraInfo_Response__create(
    ) -> *mut sensor_msgs__srv__SetCameraInfo_Response;
    pub fn sensor_msgs__srv__SetCameraInfo_Response__destroy(
        msg: *mut sensor_msgs__srv__SetCameraInfo_Response,
    );
    pub fn sensor_msgs__srv__SetCameraInfo_Response__Sequence__init(
        array: *mut sensor_msgs__srv__SetCameraInfo_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn sensor_msgs__srv__SetCameraInfo_Response__Sequence__fini(
        array: *mut sensor_msgs__srv__SetCameraInfo_Response__Sequence,
    );
    pub fn sensor_msgs__srv__SetCameraInfo_Response__Sequence__create(
        size: usize,
    ) -> *mut sensor_msgs__srv__SetCameraInfo_Response__Sequence;
    pub fn sensor_msgs__srv__SetCameraInfo_Response__Sequence__destroy(
        array: *mut sensor_msgs__srv__SetCameraInfo_Response__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__srv__SetCameraInfo_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__sensor_msgs__srv__SetCameraInfo_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__sensor_msgs__srv__SetCameraInfo(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__shape_msgs__msg__Mesh(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__shape_msgs__msg__MeshTriangle(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__shape_msgs__msg__Plane(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__shape_msgs__msg__SolidPrimitive(
    ) -> *const rosidl_message_type_support_t;
    pub fn shape_msgs__msg__Mesh__create() -> *mut shape_msgs__msg__Mesh;
    pub fn shape_msgs__msg__Mesh__destroy(msg: *mut shape_msgs__msg__Mesh);
    pub fn shape_msgs__msg__Mesh__Sequence__init(
        array: *mut shape_msgs__msg__Mesh__Sequence,
        size: usize,
    ) -> bool;
    pub fn shape_msgs__msg__Mesh__Sequence__fini(array: *mut shape_msgs__msg__Mesh__Sequence);
    pub fn shape_msgs__msg__Mesh__Sequence__create(
        size: usize,
    ) -> *mut shape_msgs__msg__Mesh__Sequence;
    pub fn shape_msgs__msg__Mesh__Sequence__destroy(array: *mut shape_msgs__msg__Mesh__Sequence);
    pub fn rosidl_typesupport_c__get_message_type_support_handle__shape_msgs__msg__Mesh(
    ) -> *const rosidl_message_type_support_t;
    pub fn shape_msgs__msg__MeshTriangle__create() -> *mut shape_msgs__msg__MeshTriangle;
    pub fn shape_msgs__msg__MeshTriangle__destroy(msg: *mut shape_msgs__msg__MeshTriangle);
    pub fn shape_msgs__msg__MeshTriangle__Sequence__init(
        array: *mut shape_msgs__msg__MeshTriangle__Sequence,
        size: usize,
    ) -> bool;
    pub fn shape_msgs__msg__MeshTriangle__Sequence__fini(
        array: *mut shape_msgs__msg__MeshTriangle__Sequence,
    );
    pub fn shape_msgs__msg__MeshTriangle__Sequence__create(
        size: usize,
    ) -> *mut shape_msgs__msg__MeshTriangle__Sequence;
    pub fn shape_msgs__msg__MeshTriangle__Sequence__destroy(
        array: *mut shape_msgs__msg__MeshTriangle__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__shape_msgs__msg__MeshTriangle(
    ) -> *const rosidl_message_type_support_t;
    pub fn shape_msgs__msg__Plane__create() -> *mut shape_msgs__msg__Plane;
    pub fn shape_msgs__msg__Plane__destroy(msg: *mut shape_msgs__msg__Plane);
    pub fn shape_msgs__msg__Plane__Sequence__init(
        array: *mut shape_msgs__msg__Plane__Sequence,
        size: usize,
    ) -> bool;
    pub fn shape_msgs__msg__Plane__Sequence__fini(array: *mut shape_msgs__msg__Plane__Sequence);
    pub fn shape_msgs__msg__Plane__Sequence__create(
        size: usize,
    ) -> *mut shape_msgs__msg__Plane__Sequence;
    pub fn shape_msgs__msg__Plane__Sequence__destroy(array: *mut shape_msgs__msg__Plane__Sequence);
    pub fn rosidl_typesupport_c__get_message_type_support_handle__shape_msgs__msg__Plane(
    ) -> *const rosidl_message_type_support_t;
    pub fn shape_msgs__msg__SolidPrimitive__create() -> *mut shape_msgs__msg__SolidPrimitive;
    pub fn shape_msgs__msg__SolidPrimitive__destroy(msg: *mut shape_msgs__msg__SolidPrimitive);
    pub fn shape_msgs__msg__SolidPrimitive__Sequence__init(
        array: *mut shape_msgs__msg__SolidPrimitive__Sequence,
        size: usize,
    ) -> bool;
    pub fn shape_msgs__msg__SolidPrimitive__Sequence__fini(
        array: *mut shape_msgs__msg__SolidPrimitive__Sequence,
    );
    pub fn shape_msgs__msg__SolidPrimitive__Sequence__create(
        size: usize,
    ) -> *mut shape_msgs__msg__SolidPrimitive__Sequence;
    pub fn shape_msgs__msg__SolidPrimitive__Sequence__destroy(
        array: *mut shape_msgs__msg__SolidPrimitive__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__shape_msgs__msg__SolidPrimitive(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__statistics_msgs__msg__MetricsMessage(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__statistics_msgs__msg__StatisticDataPoint(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__statistics_msgs__msg__StatisticDataType(
    ) -> *const rosidl_message_type_support_t;
    pub fn statistics_msgs__msg__MetricsMessage__create(
    ) -> *mut statistics_msgs__msg__MetricsMessage;
    pub fn statistics_msgs__msg__MetricsMessage__destroy(
        msg: *mut statistics_msgs__msg__MetricsMessage,
    );
    pub fn statistics_msgs__msg__MetricsMessage__Sequence__init(
        array: *mut statistics_msgs__msg__MetricsMessage__Sequence,
        size: usize,
    ) -> bool;
    pub fn statistics_msgs__msg__MetricsMessage__Sequence__fini(
        array: *mut statistics_msgs__msg__MetricsMessage__Sequence,
    );
    pub fn statistics_msgs__msg__MetricsMessage__Sequence__create(
        size: usize,
    ) -> *mut statistics_msgs__msg__MetricsMessage__Sequence;
    pub fn statistics_msgs__msg__MetricsMessage__Sequence__destroy(
        array: *mut statistics_msgs__msg__MetricsMessage__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__statistics_msgs__msg__MetricsMessage(
    ) -> *const rosidl_message_type_support_t;
    pub fn statistics_msgs__msg__StatisticDataPoint__create(
    ) -> *mut statistics_msgs__msg__StatisticDataPoint;
    pub fn statistics_msgs__msg__StatisticDataPoint__destroy(
        msg: *mut statistics_msgs__msg__StatisticDataPoint,
    );
    pub fn statistics_msgs__msg__StatisticDataPoint__Sequence__init(
        array: *mut statistics_msgs__msg__StatisticDataPoint__Sequence,
        size: usize,
    ) -> bool;
    pub fn statistics_msgs__msg__StatisticDataPoint__Sequence__fini(
        array: *mut statistics_msgs__msg__StatisticDataPoint__Sequence,
    );
    pub fn statistics_msgs__msg__StatisticDataPoint__Sequence__create(
        size: usize,
    ) -> *mut statistics_msgs__msg__StatisticDataPoint__Sequence;
    pub fn statistics_msgs__msg__StatisticDataPoint__Sequence__destroy(
        array: *mut statistics_msgs__msg__StatisticDataPoint__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__statistics_msgs__msg__StatisticDataPoint(
    ) -> *const rosidl_message_type_support_t;
    pub fn statistics_msgs__msg__StatisticDataType__create(
    ) -> *mut statistics_msgs__msg__StatisticDataType;
    pub fn statistics_msgs__msg__StatisticDataType__destroy(
        msg: *mut statistics_msgs__msg__StatisticDataType,
    );
    pub fn statistics_msgs__msg__StatisticDataType__Sequence__init(
        array: *mut statistics_msgs__msg__StatisticDataType__Sequence,
        size: usize,
    ) -> bool;
    pub fn statistics_msgs__msg__StatisticDataType__Sequence__fini(
        array: *mut statistics_msgs__msg__StatisticDataType__Sequence,
    );
    pub fn statistics_msgs__msg__StatisticDataType__Sequence__create(
        size: usize,
    ) -> *mut statistics_msgs__msg__StatisticDataType__Sequence;
    pub fn statistics_msgs__msg__StatisticDataType__Sequence__destroy(
        array: *mut statistics_msgs__msg__StatisticDataType__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__statistics_msgs__msg__StatisticDataType(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__Bool__create() -> *mut std_msgs__msg__Bool;
    pub fn std_msgs__msg__Bool__destroy(msg: *mut std_msgs__msg__Bool);
    pub fn std_msgs__msg__Bool__Sequence__init(
        array: *mut std_msgs__msg__Bool__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__Bool__Sequence__fini(array: *mut std_msgs__msg__Bool__Sequence);
    pub fn std_msgs__msg__Bool__Sequence__create(size: usize)
        -> *mut std_msgs__msg__Bool__Sequence;
    pub fn std_msgs__msg__Bool__Sequence__destroy(array: *mut std_msgs__msg__Bool__Sequence);
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Bool(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__Byte__create() -> *mut std_msgs__msg__Byte;
    pub fn std_msgs__msg__Byte__destroy(msg: *mut std_msgs__msg__Byte);
    pub fn std_msgs__msg__Byte__Sequence__init(
        array: *mut std_msgs__msg__Byte__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__Byte__Sequence__fini(array: *mut std_msgs__msg__Byte__Sequence);
    pub fn std_msgs__msg__Byte__Sequence__create(size: usize)
        -> *mut std_msgs__msg__Byte__Sequence;
    pub fn std_msgs__msg__Byte__Sequence__destroy(array: *mut std_msgs__msg__Byte__Sequence);
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Byte(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__ByteMultiArray__create() -> *mut std_msgs__msg__ByteMultiArray;
    pub fn std_msgs__msg__ByteMultiArray__destroy(msg: *mut std_msgs__msg__ByteMultiArray);
    pub fn std_msgs__msg__ByteMultiArray__Sequence__init(
        array: *mut std_msgs__msg__ByteMultiArray__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__ByteMultiArray__Sequence__fini(
        array: *mut std_msgs__msg__ByteMultiArray__Sequence,
    );
    pub fn std_msgs__msg__ByteMultiArray__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__ByteMultiArray__Sequence;
    pub fn std_msgs__msg__ByteMultiArray__Sequence__destroy(
        array: *mut std_msgs__msg__ByteMultiArray__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__ByteMultiArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__Char__create() -> *mut std_msgs__msg__Char;
    pub fn std_msgs__msg__Char__destroy(msg: *mut std_msgs__msg__Char);
    pub fn std_msgs__msg__Char__Sequence__init(
        array: *mut std_msgs__msg__Char__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__Char__Sequence__fini(array: *mut std_msgs__msg__Char__Sequence);
    pub fn std_msgs__msg__Char__Sequence__create(size: usize)
        -> *mut std_msgs__msg__Char__Sequence;
    pub fn std_msgs__msg__Char__Sequence__destroy(array: *mut std_msgs__msg__Char__Sequence);
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Char(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__ColorRGBA__create() -> *mut std_msgs__msg__ColorRGBA;
    pub fn std_msgs__msg__ColorRGBA__destroy(msg: *mut std_msgs__msg__ColorRGBA);
    pub fn std_msgs__msg__ColorRGBA__Sequence__init(
        array: *mut std_msgs__msg__ColorRGBA__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__ColorRGBA__Sequence__fini(array: *mut std_msgs__msg__ColorRGBA__Sequence);
    pub fn std_msgs__msg__ColorRGBA__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__ColorRGBA__Sequence;
    pub fn std_msgs__msg__ColorRGBA__Sequence__destroy(
        array: *mut std_msgs__msg__ColorRGBA__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__ColorRGBA(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__Bool(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__Byte(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__ByteMultiArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__Char(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__ColorRGBA(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__Empty(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__Float32(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__Float32MultiArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__Float64(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__Float64MultiArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__Header(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__Int16(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__Int16MultiArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__Int32(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__Int32MultiArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__Int64(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__Int64MultiArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__Int8(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__Int8MultiArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__MultiArrayDimension(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__MultiArrayLayout(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__String(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__UInt16(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__UInt16MultiArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__UInt32(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__UInt32MultiArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__UInt64(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__UInt64MultiArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__UInt8(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__std_msgs__msg__UInt8MultiArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__Empty__create() -> *mut std_msgs__msg__Empty;
    pub fn std_msgs__msg__Empty__destroy(msg: *mut std_msgs__msg__Empty);
    pub fn std_msgs__msg__Empty__Sequence__init(
        array: *mut std_msgs__msg__Empty__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__Empty__Sequence__fini(array: *mut std_msgs__msg__Empty__Sequence);
    pub fn std_msgs__msg__Empty__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__Empty__Sequence;
    pub fn std_msgs__msg__Empty__Sequence__destroy(array: *mut std_msgs__msg__Empty__Sequence);
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Empty(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__Float32__create() -> *mut std_msgs__msg__Float32;
    pub fn std_msgs__msg__Float32__destroy(msg: *mut std_msgs__msg__Float32);
    pub fn std_msgs__msg__Float32__Sequence__init(
        array: *mut std_msgs__msg__Float32__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__Float32__Sequence__fini(array: *mut std_msgs__msg__Float32__Sequence);
    pub fn std_msgs__msg__Float32__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__Float32__Sequence;
    pub fn std_msgs__msg__Float32__Sequence__destroy(array: *mut std_msgs__msg__Float32__Sequence);
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Float32(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__Float32MultiArray__create() -> *mut std_msgs__msg__Float32MultiArray;
    pub fn std_msgs__msg__Float32MultiArray__destroy(msg: *mut std_msgs__msg__Float32MultiArray);
    pub fn std_msgs__msg__Float32MultiArray__Sequence__init(
        array: *mut std_msgs__msg__Float32MultiArray__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__Float32MultiArray__Sequence__fini(
        array: *mut std_msgs__msg__Float32MultiArray__Sequence,
    );
    pub fn std_msgs__msg__Float32MultiArray__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__Float32MultiArray__Sequence;
    pub fn std_msgs__msg__Float32MultiArray__Sequence__destroy(
        array: *mut std_msgs__msg__Float32MultiArray__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Float32MultiArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__Float64__create() -> *mut std_msgs__msg__Float64;
    pub fn std_msgs__msg__Float64__destroy(msg: *mut std_msgs__msg__Float64);
    pub fn std_msgs__msg__Float64__Sequence__init(
        array: *mut std_msgs__msg__Float64__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__Float64__Sequence__fini(array: *mut std_msgs__msg__Float64__Sequence);
    pub fn std_msgs__msg__Float64__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__Float64__Sequence;
    pub fn std_msgs__msg__Float64__Sequence__destroy(array: *mut std_msgs__msg__Float64__Sequence);
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Float64(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__Float64MultiArray__create() -> *mut std_msgs__msg__Float64MultiArray;
    pub fn std_msgs__msg__Float64MultiArray__destroy(msg: *mut std_msgs__msg__Float64MultiArray);
    pub fn std_msgs__msg__Float64MultiArray__Sequence__init(
        array: *mut std_msgs__msg__Float64MultiArray__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__Float64MultiArray__Sequence__fini(
        array: *mut std_msgs__msg__Float64MultiArray__Sequence,
    );
    pub fn std_msgs__msg__Float64MultiArray__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__Float64MultiArray__Sequence;
    pub fn std_msgs__msg__Float64MultiArray__Sequence__destroy(
        array: *mut std_msgs__msg__Float64MultiArray__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Float64MultiArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__Header__create() -> *mut std_msgs__msg__Header;
    pub fn std_msgs__msg__Header__destroy(msg: *mut std_msgs__msg__Header);
    pub fn std_msgs__msg__Header__Sequence__init(
        array: *mut std_msgs__msg__Header__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__Header__Sequence__fini(array: *mut std_msgs__msg__Header__Sequence);
    pub fn std_msgs__msg__Header__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__Header__Sequence;
    pub fn std_msgs__msg__Header__Sequence__destroy(array: *mut std_msgs__msg__Header__Sequence);
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Header(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__Int16__create() -> *mut std_msgs__msg__Int16;
    pub fn std_msgs__msg__Int16__destroy(msg: *mut std_msgs__msg__Int16);
    pub fn std_msgs__msg__Int16__Sequence__init(
        array: *mut std_msgs__msg__Int16__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__Int16__Sequence__fini(array: *mut std_msgs__msg__Int16__Sequence);
    pub fn std_msgs__msg__Int16__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__Int16__Sequence;
    pub fn std_msgs__msg__Int16__Sequence__destroy(array: *mut std_msgs__msg__Int16__Sequence);
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Int16(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__Int16MultiArray__create() -> *mut std_msgs__msg__Int16MultiArray;
    pub fn std_msgs__msg__Int16MultiArray__destroy(msg: *mut std_msgs__msg__Int16MultiArray);
    pub fn std_msgs__msg__Int16MultiArray__Sequence__init(
        array: *mut std_msgs__msg__Int16MultiArray__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__Int16MultiArray__Sequence__fini(
        array: *mut std_msgs__msg__Int16MultiArray__Sequence,
    );
    pub fn std_msgs__msg__Int16MultiArray__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__Int16MultiArray__Sequence;
    pub fn std_msgs__msg__Int16MultiArray__Sequence__destroy(
        array: *mut std_msgs__msg__Int16MultiArray__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Int16MultiArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__Int32__create() -> *mut std_msgs__msg__Int32;
    pub fn std_msgs__msg__Int32__destroy(msg: *mut std_msgs__msg__Int32);
    pub fn std_msgs__msg__Int32__Sequence__init(
        array: *mut std_msgs__msg__Int32__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__Int32__Sequence__fini(array: *mut std_msgs__msg__Int32__Sequence);
    pub fn std_msgs__msg__Int32__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__Int32__Sequence;
    pub fn std_msgs__msg__Int32__Sequence__destroy(array: *mut std_msgs__msg__Int32__Sequence);
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Int32(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__Int32MultiArray__create() -> *mut std_msgs__msg__Int32MultiArray;
    pub fn std_msgs__msg__Int32MultiArray__destroy(msg: *mut std_msgs__msg__Int32MultiArray);
    pub fn std_msgs__msg__Int32MultiArray__Sequence__init(
        array: *mut std_msgs__msg__Int32MultiArray__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__Int32MultiArray__Sequence__fini(
        array: *mut std_msgs__msg__Int32MultiArray__Sequence,
    );
    pub fn std_msgs__msg__Int32MultiArray__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__Int32MultiArray__Sequence;
    pub fn std_msgs__msg__Int32MultiArray__Sequence__destroy(
        array: *mut std_msgs__msg__Int32MultiArray__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Int32MultiArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__Int64__create() -> *mut std_msgs__msg__Int64;
    pub fn std_msgs__msg__Int64__destroy(msg: *mut std_msgs__msg__Int64);
    pub fn std_msgs__msg__Int64__Sequence__init(
        array: *mut std_msgs__msg__Int64__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__Int64__Sequence__fini(array: *mut std_msgs__msg__Int64__Sequence);
    pub fn std_msgs__msg__Int64__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__Int64__Sequence;
    pub fn std_msgs__msg__Int64__Sequence__destroy(array: *mut std_msgs__msg__Int64__Sequence);
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Int64(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__Int64MultiArray__create() -> *mut std_msgs__msg__Int64MultiArray;
    pub fn std_msgs__msg__Int64MultiArray__destroy(msg: *mut std_msgs__msg__Int64MultiArray);
    pub fn std_msgs__msg__Int64MultiArray__Sequence__init(
        array: *mut std_msgs__msg__Int64MultiArray__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__Int64MultiArray__Sequence__fini(
        array: *mut std_msgs__msg__Int64MultiArray__Sequence,
    );
    pub fn std_msgs__msg__Int64MultiArray__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__Int64MultiArray__Sequence;
    pub fn std_msgs__msg__Int64MultiArray__Sequence__destroy(
        array: *mut std_msgs__msg__Int64MultiArray__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Int64MultiArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__Int8__create() -> *mut std_msgs__msg__Int8;
    pub fn std_msgs__msg__Int8__destroy(msg: *mut std_msgs__msg__Int8);
    pub fn std_msgs__msg__Int8__Sequence__init(
        array: *mut std_msgs__msg__Int8__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__Int8__Sequence__fini(array: *mut std_msgs__msg__Int8__Sequence);
    pub fn std_msgs__msg__Int8__Sequence__create(size: usize)
        -> *mut std_msgs__msg__Int8__Sequence;
    pub fn std_msgs__msg__Int8__Sequence__destroy(array: *mut std_msgs__msg__Int8__Sequence);
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Int8(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__Int8MultiArray__create() -> *mut std_msgs__msg__Int8MultiArray;
    pub fn std_msgs__msg__Int8MultiArray__destroy(msg: *mut std_msgs__msg__Int8MultiArray);
    pub fn std_msgs__msg__Int8MultiArray__Sequence__init(
        array: *mut std_msgs__msg__Int8MultiArray__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__Int8MultiArray__Sequence__fini(
        array: *mut std_msgs__msg__Int8MultiArray__Sequence,
    );
    pub fn std_msgs__msg__Int8MultiArray__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__Int8MultiArray__Sequence;
    pub fn std_msgs__msg__Int8MultiArray__Sequence__destroy(
        array: *mut std_msgs__msg__Int8MultiArray__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__Int8MultiArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__MultiArrayDimension__create() -> *mut std_msgs__msg__MultiArrayDimension;
    pub fn std_msgs__msg__MultiArrayDimension__destroy(
        msg: *mut std_msgs__msg__MultiArrayDimension,
    );
    pub fn std_msgs__msg__MultiArrayDimension__Sequence__init(
        array: *mut std_msgs__msg__MultiArrayDimension__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__MultiArrayDimension__Sequence__fini(
        array: *mut std_msgs__msg__MultiArrayDimension__Sequence,
    );
    pub fn std_msgs__msg__MultiArrayDimension__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__MultiArrayDimension__Sequence;
    pub fn std_msgs__msg__MultiArrayDimension__Sequence__destroy(
        array: *mut std_msgs__msg__MultiArrayDimension__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__MultiArrayDimension(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__MultiArrayLayout__create() -> *mut std_msgs__msg__MultiArrayLayout;
    pub fn std_msgs__msg__MultiArrayLayout__destroy(msg: *mut std_msgs__msg__MultiArrayLayout);
    pub fn std_msgs__msg__MultiArrayLayout__Sequence__init(
        array: *mut std_msgs__msg__MultiArrayLayout__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__MultiArrayLayout__Sequence__fini(
        array: *mut std_msgs__msg__MultiArrayLayout__Sequence,
    );
    pub fn std_msgs__msg__MultiArrayLayout__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__MultiArrayLayout__Sequence;
    pub fn std_msgs__msg__MultiArrayLayout__Sequence__destroy(
        array: *mut std_msgs__msg__MultiArrayLayout__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__MultiArrayLayout(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__String__create() -> *mut std_msgs__msg__String;
    pub fn std_msgs__msg__String__destroy(msg: *mut std_msgs__msg__String);
    pub fn std_msgs__msg__String__Sequence__init(
        array: *mut std_msgs__msg__String__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__String__Sequence__fini(array: *mut std_msgs__msg__String__Sequence);
    pub fn std_msgs__msg__String__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__String__Sequence;
    pub fn std_msgs__msg__String__Sequence__destroy(array: *mut std_msgs__msg__String__Sequence);
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__String(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__UInt16__create() -> *mut std_msgs__msg__UInt16;
    pub fn std_msgs__msg__UInt16__destroy(msg: *mut std_msgs__msg__UInt16);
    pub fn std_msgs__msg__UInt16__Sequence__init(
        array: *mut std_msgs__msg__UInt16__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__UInt16__Sequence__fini(array: *mut std_msgs__msg__UInt16__Sequence);
    pub fn std_msgs__msg__UInt16__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__UInt16__Sequence;
    pub fn std_msgs__msg__UInt16__Sequence__destroy(array: *mut std_msgs__msg__UInt16__Sequence);
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__UInt16(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__UInt16MultiArray__create() -> *mut std_msgs__msg__UInt16MultiArray;
    pub fn std_msgs__msg__UInt16MultiArray__destroy(msg: *mut std_msgs__msg__UInt16MultiArray);
    pub fn std_msgs__msg__UInt16MultiArray__Sequence__init(
        array: *mut std_msgs__msg__UInt16MultiArray__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__UInt16MultiArray__Sequence__fini(
        array: *mut std_msgs__msg__UInt16MultiArray__Sequence,
    );
    pub fn std_msgs__msg__UInt16MultiArray__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__UInt16MultiArray__Sequence;
    pub fn std_msgs__msg__UInt16MultiArray__Sequence__destroy(
        array: *mut std_msgs__msg__UInt16MultiArray__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__UInt16MultiArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__UInt32__create() -> *mut std_msgs__msg__UInt32;
    pub fn std_msgs__msg__UInt32__destroy(msg: *mut std_msgs__msg__UInt32);
    pub fn std_msgs__msg__UInt32__Sequence__init(
        array: *mut std_msgs__msg__UInt32__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__UInt32__Sequence__fini(array: *mut std_msgs__msg__UInt32__Sequence);
    pub fn std_msgs__msg__UInt32__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__UInt32__Sequence;
    pub fn std_msgs__msg__UInt32__Sequence__destroy(array: *mut std_msgs__msg__UInt32__Sequence);
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__UInt32(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__UInt32MultiArray__create() -> *mut std_msgs__msg__UInt32MultiArray;
    pub fn std_msgs__msg__UInt32MultiArray__destroy(msg: *mut std_msgs__msg__UInt32MultiArray);
    pub fn std_msgs__msg__UInt32MultiArray__Sequence__init(
        array: *mut std_msgs__msg__UInt32MultiArray__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__UInt32MultiArray__Sequence__fini(
        array: *mut std_msgs__msg__UInt32MultiArray__Sequence,
    );
    pub fn std_msgs__msg__UInt32MultiArray__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__UInt32MultiArray__Sequence;
    pub fn std_msgs__msg__UInt32MultiArray__Sequence__destroy(
        array: *mut std_msgs__msg__UInt32MultiArray__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__UInt32MultiArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__UInt64__create() -> *mut std_msgs__msg__UInt64;
    pub fn std_msgs__msg__UInt64__destroy(msg: *mut std_msgs__msg__UInt64);
    pub fn std_msgs__msg__UInt64__Sequence__init(
        array: *mut std_msgs__msg__UInt64__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__UInt64__Sequence__fini(array: *mut std_msgs__msg__UInt64__Sequence);
    pub fn std_msgs__msg__UInt64__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__UInt64__Sequence;
    pub fn std_msgs__msg__UInt64__Sequence__destroy(array: *mut std_msgs__msg__UInt64__Sequence);
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__UInt64(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__UInt64MultiArray__create() -> *mut std_msgs__msg__UInt64MultiArray;
    pub fn std_msgs__msg__UInt64MultiArray__destroy(msg: *mut std_msgs__msg__UInt64MultiArray);
    pub fn std_msgs__msg__UInt64MultiArray__Sequence__init(
        array: *mut std_msgs__msg__UInt64MultiArray__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__UInt64MultiArray__Sequence__fini(
        array: *mut std_msgs__msg__UInt64MultiArray__Sequence,
    );
    pub fn std_msgs__msg__UInt64MultiArray__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__UInt64MultiArray__Sequence;
    pub fn std_msgs__msg__UInt64MultiArray__Sequence__destroy(
        array: *mut std_msgs__msg__UInt64MultiArray__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__UInt64MultiArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__UInt8__create() -> *mut std_msgs__msg__UInt8;
    pub fn std_msgs__msg__UInt8__destroy(msg: *mut std_msgs__msg__UInt8);
    pub fn std_msgs__msg__UInt8__Sequence__init(
        array: *mut std_msgs__msg__UInt8__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__UInt8__Sequence__fini(array: *mut std_msgs__msg__UInt8__Sequence);
    pub fn std_msgs__msg__UInt8__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__UInt8__Sequence;
    pub fn std_msgs__msg__UInt8__Sequence__destroy(array: *mut std_msgs__msg__UInt8__Sequence);
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__UInt8(
    ) -> *const rosidl_message_type_support_t;
    pub fn std_msgs__msg__UInt8MultiArray__create() -> *mut std_msgs__msg__UInt8MultiArray;
    pub fn std_msgs__msg__UInt8MultiArray__destroy(msg: *mut std_msgs__msg__UInt8MultiArray);
    pub fn std_msgs__msg__UInt8MultiArray__Sequence__init(
        array: *mut std_msgs__msg__UInt8MultiArray__Sequence,
        size: usize,
    ) -> bool;
    pub fn std_msgs__msg__UInt8MultiArray__Sequence__fini(
        array: *mut std_msgs__msg__UInt8MultiArray__Sequence,
    );
    pub fn std_msgs__msg__UInt8MultiArray__Sequence__create(
        size: usize,
    ) -> *mut std_msgs__msg__UInt8MultiArray__Sequence;
    pub fn std_msgs__msg__UInt8MultiArray__Sequence__destroy(
        array: *mut std_msgs__msg__UInt8MultiArray__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__std_msgs__msg__UInt8MultiArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__stereo_msgs__msg__DisparityImage(
    ) -> *const rosidl_message_type_support_t;
    pub fn stereo_msgs__msg__DisparityImage__create() -> *mut stereo_msgs__msg__DisparityImage;
    pub fn stereo_msgs__msg__DisparityImage__destroy(msg: *mut stereo_msgs__msg__DisparityImage);
    pub fn stereo_msgs__msg__DisparityImage__Sequence__init(
        array: *mut stereo_msgs__msg__DisparityImage__Sequence,
        size: usize,
    ) -> bool;
    pub fn stereo_msgs__msg__DisparityImage__Sequence__fini(
        array: *mut stereo_msgs__msg__DisparityImage__Sequence,
    );
    pub fn stereo_msgs__msg__DisparityImage__Sequence__create(
        size: usize,
    ) -> *mut stereo_msgs__msg__DisparityImage__Sequence;
    pub fn stereo_msgs__msg__DisparityImage__Sequence__destroy(
        array: *mut stereo_msgs__msg__DisparityImage__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__stereo_msgs__msg__DisparityImage(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__action__Fibonacci_Goal(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__action__Fibonacci_Result(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__action__Fibonacci_Feedback(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__action__Fibonacci_SendGoal_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__action__Fibonacci_SendGoal_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__test_msgs__action__Fibonacci_SendGoal(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__action__Fibonacci_GetResult_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__action__Fibonacci_GetResult_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__test_msgs__action__Fibonacci_GetResult(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__action__Fibonacci_FeedbackMessage(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__action__NestedMessage_Goal(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__action__NestedMessage_Result(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__action__NestedMessage_Feedback(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__action__NestedMessage_SendGoal_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__action__NestedMessage_SendGoal_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__test_msgs__action__NestedMessage_SendGoal(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__action__NestedMessage_GetResult_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__action__NestedMessage_GetResult_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__test_msgs__action__NestedMessage_GetResult(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__action__NestedMessage_FeedbackMessage(
    ) -> *const rosidl_message_type_support_t;
    pub fn test_msgs__action__Fibonacci_Goal__create() -> *mut test_msgs__action__Fibonacci_Goal;
    pub fn test_msgs__action__Fibonacci_Goal__destroy(msg: *mut test_msgs__action__Fibonacci_Goal);
    pub fn test_msgs__action__Fibonacci_Goal__Sequence__init(
        array: *mut test_msgs__action__Fibonacci_Goal__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__action__Fibonacci_Goal__Sequence__fini(
        array: *mut test_msgs__action__Fibonacci_Goal__Sequence,
    );
    pub fn test_msgs__action__Fibonacci_Goal__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__action__Fibonacci_Goal__Sequence;
    pub fn test_msgs__action__Fibonacci_Goal__Sequence__destroy(
        array: *mut test_msgs__action__Fibonacci_Goal__Sequence,
    );
    pub fn test_msgs__action__Fibonacci_Result__create() -> *mut test_msgs__action__Fibonacci_Result;
    pub fn test_msgs__action__Fibonacci_Result__destroy(
        msg: *mut test_msgs__action__Fibonacci_Result,
    );
    pub fn test_msgs__action__Fibonacci_Result__Sequence__init(
        array: *mut test_msgs__action__Fibonacci_Result__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__action__Fibonacci_Result__Sequence__fini(
        array: *mut test_msgs__action__Fibonacci_Result__Sequence,
    );
    pub fn test_msgs__action__Fibonacci_Result__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__action__Fibonacci_Result__Sequence;
    pub fn test_msgs__action__Fibonacci_Result__Sequence__destroy(
        array: *mut test_msgs__action__Fibonacci_Result__Sequence,
    );
    pub fn test_msgs__action__Fibonacci_Feedback__create(
    ) -> *mut test_msgs__action__Fibonacci_Feedback;
    pub fn test_msgs__action__Fibonacci_Feedback__destroy(
        msg: *mut test_msgs__action__Fibonacci_Feedback,
    );
    pub fn test_msgs__action__Fibonacci_Feedback__Sequence__init(
        array: *mut test_msgs__action__Fibonacci_Feedback__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__action__Fibonacci_Feedback__Sequence__fini(
        array: *mut test_msgs__action__Fibonacci_Feedback__Sequence,
    );
    pub fn test_msgs__action__Fibonacci_Feedback__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__action__Fibonacci_Feedback__Sequence;
    pub fn test_msgs__action__Fibonacci_Feedback__Sequence__destroy(
        array: *mut test_msgs__action__Fibonacci_Feedback__Sequence,
    );
    pub fn test_msgs__action__Fibonacci_SendGoal_Request__create(
    ) -> *mut test_msgs__action__Fibonacci_SendGoal_Request;
    pub fn test_msgs__action__Fibonacci_SendGoal_Request__destroy(
        msg: *mut test_msgs__action__Fibonacci_SendGoal_Request,
    );
    pub fn test_msgs__action__Fibonacci_SendGoal_Request__Sequence__init(
        array: *mut test_msgs__action__Fibonacci_SendGoal_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__action__Fibonacci_SendGoal_Request__Sequence__fini(
        array: *mut test_msgs__action__Fibonacci_SendGoal_Request__Sequence,
    );
    pub fn test_msgs__action__Fibonacci_SendGoal_Request__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__action__Fibonacci_SendGoal_Request__Sequence;
    pub fn test_msgs__action__Fibonacci_SendGoal_Request__Sequence__destroy(
        array: *mut test_msgs__action__Fibonacci_SendGoal_Request__Sequence,
    );
    pub fn test_msgs__action__Fibonacci_SendGoal_Response__create(
    ) -> *mut test_msgs__action__Fibonacci_SendGoal_Response;
    pub fn test_msgs__action__Fibonacci_SendGoal_Response__destroy(
        msg: *mut test_msgs__action__Fibonacci_SendGoal_Response,
    );
    pub fn test_msgs__action__Fibonacci_SendGoal_Response__Sequence__init(
        array: *mut test_msgs__action__Fibonacci_SendGoal_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__action__Fibonacci_SendGoal_Response__Sequence__fini(
        array: *mut test_msgs__action__Fibonacci_SendGoal_Response__Sequence,
    );
    pub fn test_msgs__action__Fibonacci_SendGoal_Response__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__action__Fibonacci_SendGoal_Response__Sequence;
    pub fn test_msgs__action__Fibonacci_SendGoal_Response__Sequence__destroy(
        array: *mut test_msgs__action__Fibonacci_SendGoal_Response__Sequence,
    );
    pub fn test_msgs__action__Fibonacci_GetResult_Request__create(
    ) -> *mut test_msgs__action__Fibonacci_GetResult_Request;
    pub fn test_msgs__action__Fibonacci_GetResult_Request__destroy(
        msg: *mut test_msgs__action__Fibonacci_GetResult_Request,
    );
    pub fn test_msgs__action__Fibonacci_GetResult_Request__Sequence__init(
        array: *mut test_msgs__action__Fibonacci_GetResult_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__action__Fibonacci_GetResult_Request__Sequence__fini(
        array: *mut test_msgs__action__Fibonacci_GetResult_Request__Sequence,
    );
    pub fn test_msgs__action__Fibonacci_GetResult_Request__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__action__Fibonacci_GetResult_Request__Sequence;
    pub fn test_msgs__action__Fibonacci_GetResult_Request__Sequence__destroy(
        array: *mut test_msgs__action__Fibonacci_GetResult_Request__Sequence,
    );
    pub fn test_msgs__action__Fibonacci_GetResult_Response__create(
    ) -> *mut test_msgs__action__Fibonacci_GetResult_Response;
    pub fn test_msgs__action__Fibonacci_GetResult_Response__destroy(
        msg: *mut test_msgs__action__Fibonacci_GetResult_Response,
    );
    pub fn test_msgs__action__Fibonacci_GetResult_Response__Sequence__init(
        array: *mut test_msgs__action__Fibonacci_GetResult_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__action__Fibonacci_GetResult_Response__Sequence__fini(
        array: *mut test_msgs__action__Fibonacci_GetResult_Response__Sequence,
    );
    pub fn test_msgs__action__Fibonacci_GetResult_Response__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__action__Fibonacci_GetResult_Response__Sequence;
    pub fn test_msgs__action__Fibonacci_GetResult_Response__Sequence__destroy(
        array: *mut test_msgs__action__Fibonacci_GetResult_Response__Sequence,
    );
    pub fn test_msgs__action__Fibonacci_FeedbackMessage__create(
    ) -> *mut test_msgs__action__Fibonacci_FeedbackMessage;
    pub fn test_msgs__action__Fibonacci_FeedbackMessage__destroy(
        msg: *mut test_msgs__action__Fibonacci_FeedbackMessage,
    );
    pub fn test_msgs__action__Fibonacci_FeedbackMessage__Sequence__init(
        array: *mut test_msgs__action__Fibonacci_FeedbackMessage__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__action__Fibonacci_FeedbackMessage__Sequence__fini(
        array: *mut test_msgs__action__Fibonacci_FeedbackMessage__Sequence,
    );
    pub fn test_msgs__action__Fibonacci_FeedbackMessage__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__action__Fibonacci_FeedbackMessage__Sequence;
    pub fn test_msgs__action__Fibonacci_FeedbackMessage__Sequence__destroy(
        array: *mut test_msgs__action__Fibonacci_FeedbackMessage__Sequence,
    );
    pub fn rosidl_typesupport_c__get_action_type_support_handle__test_msgs__action__Fibonacci(
    ) -> *const rosidl_action_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__action__Fibonacci_Goal(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__action__Fibonacci_Result(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__action__Fibonacci_Feedback(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__action__Fibonacci_SendGoal_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__action__Fibonacci_SendGoal_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__test_msgs__action__Fibonacci_SendGoal(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__action__Fibonacci_GetResult_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__action__Fibonacci_GetResult_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__test_msgs__action__Fibonacci_GetResult(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__action__Fibonacci_FeedbackMessage(
    ) -> *const rosidl_message_type_support_t;
    pub fn test_msgs__action__NestedMessage_Goal__create(
    ) -> *mut test_msgs__action__NestedMessage_Goal;
    pub fn test_msgs__action__NestedMessage_Goal__destroy(
        msg: *mut test_msgs__action__NestedMessage_Goal,
    );
    pub fn test_msgs__action__NestedMessage_Goal__Sequence__init(
        array: *mut test_msgs__action__NestedMessage_Goal__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__action__NestedMessage_Goal__Sequence__fini(
        array: *mut test_msgs__action__NestedMessage_Goal__Sequence,
    );
    pub fn test_msgs__action__NestedMessage_Goal__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__action__NestedMessage_Goal__Sequence;
    pub fn test_msgs__action__NestedMessage_Goal__Sequence__destroy(
        array: *mut test_msgs__action__NestedMessage_Goal__Sequence,
    );
    pub fn test_msgs__action__NestedMessage_Result__create(
    ) -> *mut test_msgs__action__NestedMessage_Result;
    pub fn test_msgs__action__NestedMessage_Result__destroy(
        msg: *mut test_msgs__action__NestedMessage_Result,
    );
    pub fn test_msgs__action__NestedMessage_Result__Sequence__init(
        array: *mut test_msgs__action__NestedMessage_Result__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__action__NestedMessage_Result__Sequence__fini(
        array: *mut test_msgs__action__NestedMessage_Result__Sequence,
    );
    pub fn test_msgs__action__NestedMessage_Result__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__action__NestedMessage_Result__Sequence;
    pub fn test_msgs__action__NestedMessage_Result__Sequence__destroy(
        array: *mut test_msgs__action__NestedMessage_Result__Sequence,
    );
    pub fn test_msgs__action__NestedMessage_Feedback__create(
    ) -> *mut test_msgs__action__NestedMessage_Feedback;
    pub fn test_msgs__action__NestedMessage_Feedback__destroy(
        msg: *mut test_msgs__action__NestedMessage_Feedback,
    );
    pub fn test_msgs__action__NestedMessage_Feedback__Sequence__init(
        array: *mut test_msgs__action__NestedMessage_Feedback__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__action__NestedMessage_Feedback__Sequence__fini(
        array: *mut test_msgs__action__NestedMessage_Feedback__Sequence,
    );
    pub fn test_msgs__action__NestedMessage_Feedback__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__action__NestedMessage_Feedback__Sequence;
    pub fn test_msgs__action__NestedMessage_Feedback__Sequence__destroy(
        array: *mut test_msgs__action__NestedMessage_Feedback__Sequence,
    );
    pub fn test_msgs__action__NestedMessage_SendGoal_Request__create(
    ) -> *mut test_msgs__action__NestedMessage_SendGoal_Request;
    pub fn test_msgs__action__NestedMessage_SendGoal_Request__destroy(
        msg: *mut test_msgs__action__NestedMessage_SendGoal_Request,
    );
    pub fn test_msgs__action__NestedMessage_SendGoal_Request__Sequence__init(
        array: *mut test_msgs__action__NestedMessage_SendGoal_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__action__NestedMessage_SendGoal_Request__Sequence__fini(
        array: *mut test_msgs__action__NestedMessage_SendGoal_Request__Sequence,
    );
    pub fn test_msgs__action__NestedMessage_SendGoal_Request__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__action__NestedMessage_SendGoal_Request__Sequence;
    pub fn test_msgs__action__NestedMessage_SendGoal_Request__Sequence__destroy(
        array: *mut test_msgs__action__NestedMessage_SendGoal_Request__Sequence,
    );
    pub fn test_msgs__action__NestedMessage_SendGoal_Response__create(
    ) -> *mut test_msgs__action__NestedMessage_SendGoal_Response;
    pub fn test_msgs__action__NestedMessage_SendGoal_Response__destroy(
        msg: *mut test_msgs__action__NestedMessage_SendGoal_Response,
    );
    pub fn test_msgs__action__NestedMessage_SendGoal_Response__Sequence__init(
        array: *mut test_msgs__action__NestedMessage_SendGoal_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__action__NestedMessage_SendGoal_Response__Sequence__fini(
        array: *mut test_msgs__action__NestedMessage_SendGoal_Response__Sequence,
    );
    pub fn test_msgs__action__NestedMessage_SendGoal_Response__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__action__NestedMessage_SendGoal_Response__Sequence;
    pub fn test_msgs__action__NestedMessage_SendGoal_Response__Sequence__destroy(
        array: *mut test_msgs__action__NestedMessage_SendGoal_Response__Sequence,
    );
    pub fn test_msgs__action__NestedMessage_GetResult_Request__create(
    ) -> *mut test_msgs__action__NestedMessage_GetResult_Request;
    pub fn test_msgs__action__NestedMessage_GetResult_Request__destroy(
        msg: *mut test_msgs__action__NestedMessage_GetResult_Request,
    );
    pub fn test_msgs__action__NestedMessage_GetResult_Request__Sequence__init(
        array: *mut test_msgs__action__NestedMessage_GetResult_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__action__NestedMessage_GetResult_Request__Sequence__fini(
        array: *mut test_msgs__action__NestedMessage_GetResult_Request__Sequence,
    );
    pub fn test_msgs__action__NestedMessage_GetResult_Request__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__action__NestedMessage_GetResult_Request__Sequence;
    pub fn test_msgs__action__NestedMessage_GetResult_Request__Sequence__destroy(
        array: *mut test_msgs__action__NestedMessage_GetResult_Request__Sequence,
    );
    pub fn test_msgs__action__NestedMessage_GetResult_Response__create(
    ) -> *mut test_msgs__action__NestedMessage_GetResult_Response;
    pub fn test_msgs__action__NestedMessage_GetResult_Response__destroy(
        msg: *mut test_msgs__action__NestedMessage_GetResult_Response,
    );
    pub fn test_msgs__action__NestedMessage_GetResult_Response__Sequence__init(
        array: *mut test_msgs__action__NestedMessage_GetResult_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__action__NestedMessage_GetResult_Response__Sequence__fini(
        array: *mut test_msgs__action__NestedMessage_GetResult_Response__Sequence,
    );
    pub fn test_msgs__action__NestedMessage_GetResult_Response__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__action__NestedMessage_GetResult_Response__Sequence;
    pub fn test_msgs__action__NestedMessage_GetResult_Response__Sequence__destroy(
        array: *mut test_msgs__action__NestedMessage_GetResult_Response__Sequence,
    );
    pub fn test_msgs__action__NestedMessage_FeedbackMessage__create(
    ) -> *mut test_msgs__action__NestedMessage_FeedbackMessage;
    pub fn test_msgs__action__NestedMessage_FeedbackMessage__destroy(
        msg: *mut test_msgs__action__NestedMessage_FeedbackMessage,
    );
    pub fn test_msgs__action__NestedMessage_FeedbackMessage__Sequence__init(
        array: *mut test_msgs__action__NestedMessage_FeedbackMessage__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__action__NestedMessage_FeedbackMessage__Sequence__fini(
        array: *mut test_msgs__action__NestedMessage_FeedbackMessage__Sequence,
    );
    pub fn test_msgs__action__NestedMessage_FeedbackMessage__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__action__NestedMessage_FeedbackMessage__Sequence;
    pub fn test_msgs__action__NestedMessage_FeedbackMessage__Sequence__destroy(
        array: *mut test_msgs__action__NestedMessage_FeedbackMessage__Sequence,
    );
    pub fn rosidl_typesupport_c__get_action_type_support_handle__test_msgs__action__NestedMessage(
    ) -> *const rosidl_action_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__action__NestedMessage_Goal(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__action__NestedMessage_Result(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__action__NestedMessage_Feedback(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__action__NestedMessage_SendGoal_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__action__NestedMessage_SendGoal_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__test_msgs__action__NestedMessage_SendGoal(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__action__NestedMessage_GetResult_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__action__NestedMessage_GetResult_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__test_msgs__action__NestedMessage_GetResult(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__action__NestedMessage_FeedbackMessage(
    ) -> *const rosidl_message_type_support_t;
    pub fn test_msgs__msg__Arrays__create() -> *mut test_msgs__msg__Arrays;
    pub fn test_msgs__msg__Arrays__destroy(msg: *mut test_msgs__msg__Arrays);
    pub fn test_msgs__msg__Arrays__Sequence__init(
        array: *mut test_msgs__msg__Arrays__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__msg__Arrays__Sequence__fini(array: *mut test_msgs__msg__Arrays__Sequence);
    pub fn test_msgs__msg__Arrays__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__msg__Arrays__Sequence;
    pub fn test_msgs__msg__Arrays__Sequence__destroy(array: *mut test_msgs__msg__Arrays__Sequence);
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__msg__Arrays(
    ) -> *const rosidl_message_type_support_t;
    pub fn test_msgs__msg__BasicTypes__create() -> *mut test_msgs__msg__BasicTypes;
    pub fn test_msgs__msg__BasicTypes__destroy(msg: *mut test_msgs__msg__BasicTypes);
    pub fn test_msgs__msg__BasicTypes__Sequence__init(
        array: *mut test_msgs__msg__BasicTypes__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__msg__BasicTypes__Sequence__fini(
        array: *mut test_msgs__msg__BasicTypes__Sequence,
    );
    pub fn test_msgs__msg__BasicTypes__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__msg__BasicTypes__Sequence;
    pub fn test_msgs__msg__BasicTypes__Sequence__destroy(
        array: *mut test_msgs__msg__BasicTypes__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__msg__BasicTypes(
    ) -> *const rosidl_message_type_support_t;
    pub fn test_msgs__msg__BoundedPlainSequences__create(
    ) -> *mut test_msgs__msg__BoundedPlainSequences;
    pub fn test_msgs__msg__BoundedPlainSequences__destroy(
        msg: *mut test_msgs__msg__BoundedPlainSequences,
    );
    pub fn test_msgs__msg__BoundedPlainSequences__Sequence__init(
        array: *mut test_msgs__msg__BoundedPlainSequences__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__msg__BoundedPlainSequences__Sequence__fini(
        array: *mut test_msgs__msg__BoundedPlainSequences__Sequence,
    );
    pub fn test_msgs__msg__BoundedPlainSequences__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__msg__BoundedPlainSequences__Sequence;
    pub fn test_msgs__msg__BoundedPlainSequences__Sequence__destroy(
        array: *mut test_msgs__msg__BoundedPlainSequences__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__msg__BoundedPlainSequences(
    ) -> *const rosidl_message_type_support_t;
    pub fn test_msgs__msg__BoundedSequences__create() -> *mut test_msgs__msg__BoundedSequences;
    pub fn test_msgs__msg__BoundedSequences__destroy(msg: *mut test_msgs__msg__BoundedSequences);
    pub fn test_msgs__msg__BoundedSequences__Sequence__init(
        array: *mut test_msgs__msg__BoundedSequences__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__msg__BoundedSequences__Sequence__fini(
        array: *mut test_msgs__msg__BoundedSequences__Sequence,
    );
    pub fn test_msgs__msg__BoundedSequences__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__msg__BoundedSequences__Sequence;
    pub fn test_msgs__msg__BoundedSequences__Sequence__destroy(
        array: *mut test_msgs__msg__BoundedSequences__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__msg__BoundedSequences(
    ) -> *const rosidl_message_type_support_t;
    pub fn test_msgs__msg__Builtins__create() -> *mut test_msgs__msg__Builtins;
    pub fn test_msgs__msg__Builtins__destroy(msg: *mut test_msgs__msg__Builtins);
    pub fn test_msgs__msg__Builtins__Sequence__init(
        array: *mut test_msgs__msg__Builtins__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__msg__Builtins__Sequence__fini(array: *mut test_msgs__msg__Builtins__Sequence);
    pub fn test_msgs__msg__Builtins__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__msg__Builtins__Sequence;
    pub fn test_msgs__msg__Builtins__Sequence__destroy(
        array: *mut test_msgs__msg__Builtins__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__msg__Builtins(
    ) -> *const rosidl_message_type_support_t;
    pub fn test_msgs__msg__Constants__create() -> *mut test_msgs__msg__Constants;
    pub fn test_msgs__msg__Constants__destroy(msg: *mut test_msgs__msg__Constants);
    pub fn test_msgs__msg__Constants__Sequence__init(
        array: *mut test_msgs__msg__Constants__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__msg__Constants__Sequence__fini(
        array: *mut test_msgs__msg__Constants__Sequence,
    );
    pub fn test_msgs__msg__Constants__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__msg__Constants__Sequence;
    pub fn test_msgs__msg__Constants__Sequence__destroy(
        array: *mut test_msgs__msg__Constants__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__msg__Constants(
    ) -> *const rosidl_message_type_support_t;
    pub fn test_msgs__msg__Defaults__create() -> *mut test_msgs__msg__Defaults;
    pub fn test_msgs__msg__Defaults__destroy(msg: *mut test_msgs__msg__Defaults);
    pub fn test_msgs__msg__Defaults__Sequence__init(
        array: *mut test_msgs__msg__Defaults__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__msg__Defaults__Sequence__fini(array: *mut test_msgs__msg__Defaults__Sequence);
    pub fn test_msgs__msg__Defaults__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__msg__Defaults__Sequence;
    pub fn test_msgs__msg__Defaults__Sequence__destroy(
        array: *mut test_msgs__msg__Defaults__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__msg__Defaults(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__msg__Arrays(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__msg__BasicTypes(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__msg__BoundedPlainSequences(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__msg__BoundedSequences(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__msg__Builtins(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__msg__Constants(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__msg__Defaults(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__msg__Empty(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__msg__MultiNested(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__msg__Nested(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__msg__Strings(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__msg__UnboundedSequences(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__msg__WStrings(
    ) -> *const rosidl_message_type_support_t;
    pub fn test_msgs__msg__Empty__create() -> *mut test_msgs__msg__Empty;
    pub fn test_msgs__msg__Empty__destroy(msg: *mut test_msgs__msg__Empty);
    pub fn test_msgs__msg__Empty__Sequence__init(
        array: *mut test_msgs__msg__Empty__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__msg__Empty__Sequence__fini(array: *mut test_msgs__msg__Empty__Sequence);
    pub fn test_msgs__msg__Empty__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__msg__Empty__Sequence;
    pub fn test_msgs__msg__Empty__Sequence__destroy(array: *mut test_msgs__msg__Empty__Sequence);
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__msg__Empty(
    ) -> *const rosidl_message_type_support_t;
    pub fn test_msgs__msg__MultiNested__create() -> *mut test_msgs__msg__MultiNested;
    pub fn test_msgs__msg__MultiNested__destroy(msg: *mut test_msgs__msg__MultiNested);
    pub fn test_msgs__msg__MultiNested__Sequence__init(
        array: *mut test_msgs__msg__MultiNested__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__msg__MultiNested__Sequence__fini(
        array: *mut test_msgs__msg__MultiNested__Sequence,
    );
    pub fn test_msgs__msg__MultiNested__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__msg__MultiNested__Sequence;
    pub fn test_msgs__msg__MultiNested__Sequence__destroy(
        array: *mut test_msgs__msg__MultiNested__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__msg__MultiNested(
    ) -> *const rosidl_message_type_support_t;
    pub fn test_msgs__msg__Nested__create() -> *mut test_msgs__msg__Nested;
    pub fn test_msgs__msg__Nested__destroy(msg: *mut test_msgs__msg__Nested);
    pub fn test_msgs__msg__Nested__Sequence__init(
        array: *mut test_msgs__msg__Nested__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__msg__Nested__Sequence__fini(array: *mut test_msgs__msg__Nested__Sequence);
    pub fn test_msgs__msg__Nested__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__msg__Nested__Sequence;
    pub fn test_msgs__msg__Nested__Sequence__destroy(array: *mut test_msgs__msg__Nested__Sequence);
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__msg__Nested(
    ) -> *const rosidl_message_type_support_t;
    pub fn test_msgs__msg__Strings__create() -> *mut test_msgs__msg__Strings;
    pub fn test_msgs__msg__Strings__destroy(msg: *mut test_msgs__msg__Strings);
    pub fn test_msgs__msg__Strings__Sequence__init(
        array: *mut test_msgs__msg__Strings__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__msg__Strings__Sequence__fini(array: *mut test_msgs__msg__Strings__Sequence);
    pub fn test_msgs__msg__Strings__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__msg__Strings__Sequence;
    pub fn test_msgs__msg__Strings__Sequence__destroy(
        array: *mut test_msgs__msg__Strings__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__msg__Strings(
    ) -> *const rosidl_message_type_support_t;
    pub fn test_msgs__msg__UnboundedSequences__create() -> *mut test_msgs__msg__UnboundedSequences;
    pub fn test_msgs__msg__UnboundedSequences__destroy(
        msg: *mut test_msgs__msg__UnboundedSequences,
    );
    pub fn test_msgs__msg__UnboundedSequences__Sequence__init(
        array: *mut test_msgs__msg__UnboundedSequences__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__msg__UnboundedSequences__Sequence__fini(
        array: *mut test_msgs__msg__UnboundedSequences__Sequence,
    );
    pub fn test_msgs__msg__UnboundedSequences__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__msg__UnboundedSequences__Sequence;
    pub fn test_msgs__msg__UnboundedSequences__Sequence__destroy(
        array: *mut test_msgs__msg__UnboundedSequences__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__msg__UnboundedSequences(
    ) -> *const rosidl_message_type_support_t;
    pub fn test_msgs__msg__WStrings__create() -> *mut test_msgs__msg__WStrings;
    pub fn test_msgs__msg__WStrings__destroy(msg: *mut test_msgs__msg__WStrings);
    pub fn test_msgs__msg__WStrings__Sequence__init(
        array: *mut test_msgs__msg__WStrings__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__msg__WStrings__Sequence__fini(array: *mut test_msgs__msg__WStrings__Sequence);
    pub fn test_msgs__msg__WStrings__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__msg__WStrings__Sequence;
    pub fn test_msgs__msg__WStrings__Sequence__destroy(
        array: *mut test_msgs__msg__WStrings__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__msg__WStrings(
    ) -> *const rosidl_message_type_support_t;
    pub fn test_msgs__srv__Arrays_Request__create() -> *mut test_msgs__srv__Arrays_Request;
    pub fn test_msgs__srv__Arrays_Request__destroy(msg: *mut test_msgs__srv__Arrays_Request);
    pub fn test_msgs__srv__Arrays_Request__Sequence__init(
        array: *mut test_msgs__srv__Arrays_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__srv__Arrays_Request__Sequence__fini(
        array: *mut test_msgs__srv__Arrays_Request__Sequence,
    );
    pub fn test_msgs__srv__Arrays_Request__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__srv__Arrays_Request__Sequence;
    pub fn test_msgs__srv__Arrays_Request__Sequence__destroy(
        array: *mut test_msgs__srv__Arrays_Request__Sequence,
    );
    pub fn test_msgs__srv__Arrays_Response__create() -> *mut test_msgs__srv__Arrays_Response;
    pub fn test_msgs__srv__Arrays_Response__destroy(msg: *mut test_msgs__srv__Arrays_Response);
    pub fn test_msgs__srv__Arrays_Response__Sequence__init(
        array: *mut test_msgs__srv__Arrays_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__srv__Arrays_Response__Sequence__fini(
        array: *mut test_msgs__srv__Arrays_Response__Sequence,
    );
    pub fn test_msgs__srv__Arrays_Response__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__srv__Arrays_Response__Sequence;
    pub fn test_msgs__srv__Arrays_Response__Sequence__destroy(
        array: *mut test_msgs__srv__Arrays_Response__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__srv__Arrays_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__srv__Arrays_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__test_msgs__srv__Arrays(
    ) -> *const rosidl_service_type_support_t;
    pub fn test_msgs__srv__BasicTypes_Request__create() -> *mut test_msgs__srv__BasicTypes_Request;
    pub fn test_msgs__srv__BasicTypes_Request__destroy(
        msg: *mut test_msgs__srv__BasicTypes_Request,
    );
    pub fn test_msgs__srv__BasicTypes_Request__Sequence__init(
        array: *mut test_msgs__srv__BasicTypes_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__srv__BasicTypes_Request__Sequence__fini(
        array: *mut test_msgs__srv__BasicTypes_Request__Sequence,
    );
    pub fn test_msgs__srv__BasicTypes_Request__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__srv__BasicTypes_Request__Sequence;
    pub fn test_msgs__srv__BasicTypes_Request__Sequence__destroy(
        array: *mut test_msgs__srv__BasicTypes_Request__Sequence,
    );
    pub fn test_msgs__srv__BasicTypes_Response__create() -> *mut test_msgs__srv__BasicTypes_Response;
    pub fn test_msgs__srv__BasicTypes_Response__destroy(
        msg: *mut test_msgs__srv__BasicTypes_Response,
    );
    pub fn test_msgs__srv__BasicTypes_Response__Sequence__init(
        array: *mut test_msgs__srv__BasicTypes_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__srv__BasicTypes_Response__Sequence__fini(
        array: *mut test_msgs__srv__BasicTypes_Response__Sequence,
    );
    pub fn test_msgs__srv__BasicTypes_Response__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__srv__BasicTypes_Response__Sequence;
    pub fn test_msgs__srv__BasicTypes_Response__Sequence__destroy(
        array: *mut test_msgs__srv__BasicTypes_Response__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__srv__BasicTypes_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__srv__BasicTypes_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__test_msgs__srv__BasicTypes(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__srv__Arrays_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__srv__Arrays_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__test_msgs__srv__Arrays(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__srv__BasicTypes_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__srv__BasicTypes_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__test_msgs__srv__BasicTypes(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__srv__Empty_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__test_msgs__srv__Empty_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__test_msgs__srv__Empty(
    ) -> *const rosidl_service_type_support_t;
    pub fn test_msgs__srv__Empty_Request__create() -> *mut test_msgs__srv__Empty_Request;
    pub fn test_msgs__srv__Empty_Request__destroy(msg: *mut test_msgs__srv__Empty_Request);
    pub fn test_msgs__srv__Empty_Request__Sequence__init(
        array: *mut test_msgs__srv__Empty_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__srv__Empty_Request__Sequence__fini(
        array: *mut test_msgs__srv__Empty_Request__Sequence,
    );
    pub fn test_msgs__srv__Empty_Request__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__srv__Empty_Request__Sequence;
    pub fn test_msgs__srv__Empty_Request__Sequence__destroy(
        array: *mut test_msgs__srv__Empty_Request__Sequence,
    );
    pub fn test_msgs__srv__Empty_Response__create() -> *mut test_msgs__srv__Empty_Response;
    pub fn test_msgs__srv__Empty_Response__destroy(msg: *mut test_msgs__srv__Empty_Response);
    pub fn test_msgs__srv__Empty_Response__Sequence__init(
        array: *mut test_msgs__srv__Empty_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn test_msgs__srv__Empty_Response__Sequence__fini(
        array: *mut test_msgs__srv__Empty_Response__Sequence,
    );
    pub fn test_msgs__srv__Empty_Response__Sequence__create(
        size: usize,
    ) -> *mut test_msgs__srv__Empty_Response__Sequence;
    pub fn test_msgs__srv__Empty_Response__Sequence__destroy(
        array: *mut test_msgs__srv__Empty_Response__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__srv__Empty_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__test_msgs__srv__Empty_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__test_msgs__srv__Empty(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__tf2_msgs__action__LookupTransform_Goal(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__tf2_msgs__action__LookupTransform_Result(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__tf2_msgs__action__LookupTransform_Feedback(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__tf2_msgs__action__LookupTransform_SendGoal_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__tf2_msgs__action__LookupTransform_SendGoal_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__tf2_msgs__action__LookupTransform_SendGoal(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__tf2_msgs__action__LookupTransform_GetResult_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__tf2_msgs__action__LookupTransform_GetResult_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__tf2_msgs__action__LookupTransform_GetResult(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__tf2_msgs__action__LookupTransform_FeedbackMessage(
    ) -> *const rosidl_message_type_support_t;
    pub fn tf2_msgs__action__LookupTransform_Goal__create(
    ) -> *mut tf2_msgs__action__LookupTransform_Goal;
    pub fn tf2_msgs__action__LookupTransform_Goal__destroy(
        msg: *mut tf2_msgs__action__LookupTransform_Goal,
    );
    pub fn tf2_msgs__action__LookupTransform_Goal__Sequence__init(
        array: *mut tf2_msgs__action__LookupTransform_Goal__Sequence,
        size: usize,
    ) -> bool;
    pub fn tf2_msgs__action__LookupTransform_Goal__Sequence__fini(
        array: *mut tf2_msgs__action__LookupTransform_Goal__Sequence,
    );
    pub fn tf2_msgs__action__LookupTransform_Goal__Sequence__create(
        size: usize,
    ) -> *mut tf2_msgs__action__LookupTransform_Goal__Sequence;
    pub fn tf2_msgs__action__LookupTransform_Goal__Sequence__destroy(
        array: *mut tf2_msgs__action__LookupTransform_Goal__Sequence,
    );
    pub fn tf2_msgs__action__LookupTransform_Result__create(
    ) -> *mut tf2_msgs__action__LookupTransform_Result;
    pub fn tf2_msgs__action__LookupTransform_Result__destroy(
        msg: *mut tf2_msgs__action__LookupTransform_Result,
    );
    pub fn tf2_msgs__action__LookupTransform_Result__Sequence__init(
        array: *mut tf2_msgs__action__LookupTransform_Result__Sequence,
        size: usize,
    ) -> bool;
    pub fn tf2_msgs__action__LookupTransform_Result__Sequence__fini(
        array: *mut tf2_msgs__action__LookupTransform_Result__Sequence,
    );
    pub fn tf2_msgs__action__LookupTransform_Result__Sequence__create(
        size: usize,
    ) -> *mut tf2_msgs__action__LookupTransform_Result__Sequence;
    pub fn tf2_msgs__action__LookupTransform_Result__Sequence__destroy(
        array: *mut tf2_msgs__action__LookupTransform_Result__Sequence,
    );
    pub fn tf2_msgs__action__LookupTransform_Feedback__create(
    ) -> *mut tf2_msgs__action__LookupTransform_Feedback;
    pub fn tf2_msgs__action__LookupTransform_Feedback__destroy(
        msg: *mut tf2_msgs__action__LookupTransform_Feedback,
    );
    pub fn tf2_msgs__action__LookupTransform_Feedback__Sequence__init(
        array: *mut tf2_msgs__action__LookupTransform_Feedback__Sequence,
        size: usize,
    ) -> bool;
    pub fn tf2_msgs__action__LookupTransform_Feedback__Sequence__fini(
        array: *mut tf2_msgs__action__LookupTransform_Feedback__Sequence,
    );
    pub fn tf2_msgs__action__LookupTransform_Feedback__Sequence__create(
        size: usize,
    ) -> *mut tf2_msgs__action__LookupTransform_Feedback__Sequence;
    pub fn tf2_msgs__action__LookupTransform_Feedback__Sequence__destroy(
        array: *mut tf2_msgs__action__LookupTransform_Feedback__Sequence,
    );
    pub fn tf2_msgs__action__LookupTransform_SendGoal_Request__create(
    ) -> *mut tf2_msgs__action__LookupTransform_SendGoal_Request;
    pub fn tf2_msgs__action__LookupTransform_SendGoal_Request__destroy(
        msg: *mut tf2_msgs__action__LookupTransform_SendGoal_Request,
    );
    pub fn tf2_msgs__action__LookupTransform_SendGoal_Request__Sequence__init(
        array: *mut tf2_msgs__action__LookupTransform_SendGoal_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn tf2_msgs__action__LookupTransform_SendGoal_Request__Sequence__fini(
        array: *mut tf2_msgs__action__LookupTransform_SendGoal_Request__Sequence,
    );
    pub fn tf2_msgs__action__LookupTransform_SendGoal_Request__Sequence__create(
        size: usize,
    ) -> *mut tf2_msgs__action__LookupTransform_SendGoal_Request__Sequence;
    pub fn tf2_msgs__action__LookupTransform_SendGoal_Request__Sequence__destroy(
        array: *mut tf2_msgs__action__LookupTransform_SendGoal_Request__Sequence,
    );
    pub fn tf2_msgs__action__LookupTransform_SendGoal_Response__create(
    ) -> *mut tf2_msgs__action__LookupTransform_SendGoal_Response;
    pub fn tf2_msgs__action__LookupTransform_SendGoal_Response__destroy(
        msg: *mut tf2_msgs__action__LookupTransform_SendGoal_Response,
    );
    pub fn tf2_msgs__action__LookupTransform_SendGoal_Response__Sequence__init(
        array: *mut tf2_msgs__action__LookupTransform_SendGoal_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn tf2_msgs__action__LookupTransform_SendGoal_Response__Sequence__fini(
        array: *mut tf2_msgs__action__LookupTransform_SendGoal_Response__Sequence,
    );
    pub fn tf2_msgs__action__LookupTransform_SendGoal_Response__Sequence__create(
        size: usize,
    ) -> *mut tf2_msgs__action__LookupTransform_SendGoal_Response__Sequence;
    pub fn tf2_msgs__action__LookupTransform_SendGoal_Response__Sequence__destroy(
        array: *mut tf2_msgs__action__LookupTransform_SendGoal_Response__Sequence,
    );
    pub fn tf2_msgs__action__LookupTransform_GetResult_Request__create(
    ) -> *mut tf2_msgs__action__LookupTransform_GetResult_Request;
    pub fn tf2_msgs__action__LookupTransform_GetResult_Request__destroy(
        msg: *mut tf2_msgs__action__LookupTransform_GetResult_Request,
    );
    pub fn tf2_msgs__action__LookupTransform_GetResult_Request__Sequence__init(
        array: *mut tf2_msgs__action__LookupTransform_GetResult_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn tf2_msgs__action__LookupTransform_GetResult_Request__Sequence__fini(
        array: *mut tf2_msgs__action__LookupTransform_GetResult_Request__Sequence,
    );
    pub fn tf2_msgs__action__LookupTransform_GetResult_Request__Sequence__create(
        size: usize,
    ) -> *mut tf2_msgs__action__LookupTransform_GetResult_Request__Sequence;
    pub fn tf2_msgs__action__LookupTransform_GetResult_Request__Sequence__destroy(
        array: *mut tf2_msgs__action__LookupTransform_GetResult_Request__Sequence,
    );
    pub fn tf2_msgs__action__LookupTransform_GetResult_Response__create(
    ) -> *mut tf2_msgs__action__LookupTransform_GetResult_Response;
    pub fn tf2_msgs__action__LookupTransform_GetResult_Response__destroy(
        msg: *mut tf2_msgs__action__LookupTransform_GetResult_Response,
    );
    pub fn tf2_msgs__action__LookupTransform_GetResult_Response__Sequence__init(
        array: *mut tf2_msgs__action__LookupTransform_GetResult_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn tf2_msgs__action__LookupTransform_GetResult_Response__Sequence__fini(
        array: *mut tf2_msgs__action__LookupTransform_GetResult_Response__Sequence,
    );
    pub fn tf2_msgs__action__LookupTransform_GetResult_Response__Sequence__create(
        size: usize,
    ) -> *mut tf2_msgs__action__LookupTransform_GetResult_Response__Sequence;
    pub fn tf2_msgs__action__LookupTransform_GetResult_Response__Sequence__destroy(
        array: *mut tf2_msgs__action__LookupTransform_GetResult_Response__Sequence,
    );
    pub fn tf2_msgs__action__LookupTransform_FeedbackMessage__create(
    ) -> *mut tf2_msgs__action__LookupTransform_FeedbackMessage;
    pub fn tf2_msgs__action__LookupTransform_FeedbackMessage__destroy(
        msg: *mut tf2_msgs__action__LookupTransform_FeedbackMessage,
    );
    pub fn tf2_msgs__action__LookupTransform_FeedbackMessage__Sequence__init(
        array: *mut tf2_msgs__action__LookupTransform_FeedbackMessage__Sequence,
        size: usize,
    ) -> bool;
    pub fn tf2_msgs__action__LookupTransform_FeedbackMessage__Sequence__fini(
        array: *mut tf2_msgs__action__LookupTransform_FeedbackMessage__Sequence,
    );
    pub fn tf2_msgs__action__LookupTransform_FeedbackMessage__Sequence__create(
        size: usize,
    ) -> *mut tf2_msgs__action__LookupTransform_FeedbackMessage__Sequence;
    pub fn tf2_msgs__action__LookupTransform_FeedbackMessage__Sequence__destroy(
        array: *mut tf2_msgs__action__LookupTransform_FeedbackMessage__Sequence,
    );
    pub fn rosidl_typesupport_c__get_action_type_support_handle__tf2_msgs__action__LookupTransform(
    ) -> *const rosidl_action_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__tf2_msgs__action__LookupTransform_Goal(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__tf2_msgs__action__LookupTransform_Result(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__tf2_msgs__action__LookupTransform_Feedback(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__tf2_msgs__action__LookupTransform_SendGoal_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__tf2_msgs__action__LookupTransform_SendGoal_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__tf2_msgs__action__LookupTransform_SendGoal(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__tf2_msgs__action__LookupTransform_GetResult_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__tf2_msgs__action__LookupTransform_GetResult_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__tf2_msgs__action__LookupTransform_GetResult(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__tf2_msgs__action__LookupTransform_FeedbackMessage(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__tf2_msgs__msg__TF2Error(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__tf2_msgs__msg__TFMessage(
    ) -> *const rosidl_message_type_support_t;
    pub fn tf2_msgs__msg__TF2Error__create() -> *mut tf2_msgs__msg__TF2Error;
    pub fn tf2_msgs__msg__TF2Error__destroy(msg: *mut tf2_msgs__msg__TF2Error);
    pub fn tf2_msgs__msg__TF2Error__Sequence__init(
        array: *mut tf2_msgs__msg__TF2Error__Sequence,
        size: usize,
    ) -> bool;
    pub fn tf2_msgs__msg__TF2Error__Sequence__fini(array: *mut tf2_msgs__msg__TF2Error__Sequence);
    pub fn tf2_msgs__msg__TF2Error__Sequence__create(
        size: usize,
    ) -> *mut tf2_msgs__msg__TF2Error__Sequence;
    pub fn tf2_msgs__msg__TF2Error__Sequence__destroy(
        array: *mut tf2_msgs__msg__TF2Error__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__tf2_msgs__msg__TF2Error(
    ) -> *const rosidl_message_type_support_t;
    pub fn tf2_msgs__msg__TFMessage__create() -> *mut tf2_msgs__msg__TFMessage;
    pub fn tf2_msgs__msg__TFMessage__destroy(msg: *mut tf2_msgs__msg__TFMessage);
    pub fn tf2_msgs__msg__TFMessage__Sequence__init(
        array: *mut tf2_msgs__msg__TFMessage__Sequence,
        size: usize,
    ) -> bool;
    pub fn tf2_msgs__msg__TFMessage__Sequence__fini(array: *mut tf2_msgs__msg__TFMessage__Sequence);
    pub fn tf2_msgs__msg__TFMessage__Sequence__create(
        size: usize,
    ) -> *mut tf2_msgs__msg__TFMessage__Sequence;
    pub fn tf2_msgs__msg__TFMessage__Sequence__destroy(
        array: *mut tf2_msgs__msg__TFMessage__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__tf2_msgs__msg__TFMessage(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__tf2_msgs__srv__FrameGraph_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__tf2_msgs__srv__FrameGraph_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__tf2_msgs__srv__FrameGraph(
    ) -> *const rosidl_service_type_support_t;
    pub fn tf2_msgs__srv__FrameGraph_Request__create() -> *mut tf2_msgs__srv__FrameGraph_Request;
    pub fn tf2_msgs__srv__FrameGraph_Request__destroy(msg: *mut tf2_msgs__srv__FrameGraph_Request);
    pub fn tf2_msgs__srv__FrameGraph_Request__Sequence__init(
        array: *mut tf2_msgs__srv__FrameGraph_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn tf2_msgs__srv__FrameGraph_Request__Sequence__fini(
        array: *mut tf2_msgs__srv__FrameGraph_Request__Sequence,
    );
    pub fn tf2_msgs__srv__FrameGraph_Request__Sequence__create(
        size: usize,
    ) -> *mut tf2_msgs__srv__FrameGraph_Request__Sequence;
    pub fn tf2_msgs__srv__FrameGraph_Request__Sequence__destroy(
        array: *mut tf2_msgs__srv__FrameGraph_Request__Sequence,
    );
    pub fn tf2_msgs__srv__FrameGraph_Response__create() -> *mut tf2_msgs__srv__FrameGraph_Response;
    pub fn tf2_msgs__srv__FrameGraph_Response__destroy(
        msg: *mut tf2_msgs__srv__FrameGraph_Response,
    );
    pub fn tf2_msgs__srv__FrameGraph_Response__Sequence__init(
        array: *mut tf2_msgs__srv__FrameGraph_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn tf2_msgs__srv__FrameGraph_Response__Sequence__fini(
        array: *mut tf2_msgs__srv__FrameGraph_Response__Sequence,
    );
    pub fn tf2_msgs__srv__FrameGraph_Response__Sequence__create(
        size: usize,
    ) -> *mut tf2_msgs__srv__FrameGraph_Response__Sequence;
    pub fn tf2_msgs__srv__FrameGraph_Response__Sequence__destroy(
        array: *mut tf2_msgs__srv__FrameGraph_Response__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__tf2_msgs__srv__FrameGraph_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__tf2_msgs__srv__FrameGraph_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__tf2_msgs__srv__FrameGraph(
    ) -> *const rosidl_service_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__trajectory_msgs__msg__JointTrajectory(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__trajectory_msgs__msg__JointTrajectoryPoint(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__trajectory_msgs__msg__MultiDOFJointTrajectory(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__trajectory_msgs__msg__MultiDOFJointTrajectoryPoint(
    ) -> *const rosidl_message_type_support_t;
    pub fn trajectory_msgs__msg__JointTrajectory__create(
    ) -> *mut trajectory_msgs__msg__JointTrajectory;
    pub fn trajectory_msgs__msg__JointTrajectory__destroy(
        msg: *mut trajectory_msgs__msg__JointTrajectory,
    );
    pub fn trajectory_msgs__msg__JointTrajectory__Sequence__init(
        array: *mut trajectory_msgs__msg__JointTrajectory__Sequence,
        size: usize,
    ) -> bool;
    pub fn trajectory_msgs__msg__JointTrajectory__Sequence__fini(
        array: *mut trajectory_msgs__msg__JointTrajectory__Sequence,
    );
    pub fn trajectory_msgs__msg__JointTrajectory__Sequence__create(
        size: usize,
    ) -> *mut trajectory_msgs__msg__JointTrajectory__Sequence;
    pub fn trajectory_msgs__msg__JointTrajectory__Sequence__destroy(
        array: *mut trajectory_msgs__msg__JointTrajectory__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__trajectory_msgs__msg__JointTrajectory(
    ) -> *const rosidl_message_type_support_t;
    pub fn trajectory_msgs__msg__JointTrajectoryPoint__create(
    ) -> *mut trajectory_msgs__msg__JointTrajectoryPoint;
    pub fn trajectory_msgs__msg__JointTrajectoryPoint__destroy(
        msg: *mut trajectory_msgs__msg__JointTrajectoryPoint,
    );
    pub fn trajectory_msgs__msg__JointTrajectoryPoint__Sequence__init(
        array: *mut trajectory_msgs__msg__JointTrajectoryPoint__Sequence,
        size: usize,
    ) -> bool;
    pub fn trajectory_msgs__msg__JointTrajectoryPoint__Sequence__fini(
        array: *mut trajectory_msgs__msg__JointTrajectoryPoint__Sequence,
    );
    pub fn trajectory_msgs__msg__JointTrajectoryPoint__Sequence__create(
        size: usize,
    ) -> *mut trajectory_msgs__msg__JointTrajectoryPoint__Sequence;
    pub fn trajectory_msgs__msg__JointTrajectoryPoint__Sequence__destroy(
        array: *mut trajectory_msgs__msg__JointTrajectoryPoint__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__trajectory_msgs__msg__JointTrajectoryPoint(
    ) -> *const rosidl_message_type_support_t;
    pub fn trajectory_msgs__msg__MultiDOFJointTrajectory__create(
    ) -> *mut trajectory_msgs__msg__MultiDOFJointTrajectory;
    pub fn trajectory_msgs__msg__MultiDOFJointTrajectory__destroy(
        msg: *mut trajectory_msgs__msg__MultiDOFJointTrajectory,
    );
    pub fn trajectory_msgs__msg__MultiDOFJointTrajectory__Sequence__init(
        array: *mut trajectory_msgs__msg__MultiDOFJointTrajectory__Sequence,
        size: usize,
    ) -> bool;
    pub fn trajectory_msgs__msg__MultiDOFJointTrajectory__Sequence__fini(
        array: *mut trajectory_msgs__msg__MultiDOFJointTrajectory__Sequence,
    );
    pub fn trajectory_msgs__msg__MultiDOFJointTrajectory__Sequence__create(
        size: usize,
    ) -> *mut trajectory_msgs__msg__MultiDOFJointTrajectory__Sequence;
    pub fn trajectory_msgs__msg__MultiDOFJointTrajectory__Sequence__destroy(
        array: *mut trajectory_msgs__msg__MultiDOFJointTrajectory__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__trajectory_msgs__msg__MultiDOFJointTrajectory(
    ) -> *const rosidl_message_type_support_t;
    pub fn trajectory_msgs__msg__MultiDOFJointTrajectoryPoint__create(
    ) -> *mut trajectory_msgs__msg__MultiDOFJointTrajectoryPoint;
    pub fn trajectory_msgs__msg__MultiDOFJointTrajectoryPoint__destroy(
        msg: *mut trajectory_msgs__msg__MultiDOFJointTrajectoryPoint,
    );
    pub fn trajectory_msgs__msg__MultiDOFJointTrajectoryPoint__Sequence__init(
        array: *mut trajectory_msgs__msg__MultiDOFJointTrajectoryPoint__Sequence,
        size: usize,
    ) -> bool;
    pub fn trajectory_msgs__msg__MultiDOFJointTrajectoryPoint__Sequence__fini(
        array: *mut trajectory_msgs__msg__MultiDOFJointTrajectoryPoint__Sequence,
    );
    pub fn trajectory_msgs__msg__MultiDOFJointTrajectoryPoint__Sequence__create(
        size: usize,
    ) -> *mut trajectory_msgs__msg__MultiDOFJointTrajectoryPoint__Sequence;
    pub fn trajectory_msgs__msg__MultiDOFJointTrajectoryPoint__Sequence__destroy(
        array: *mut trajectory_msgs__msg__MultiDOFJointTrajectoryPoint__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__trajectory_msgs__msg__MultiDOFJointTrajectoryPoint(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__unique_identifier_msgs__msg__UUID(
    ) -> *const rosidl_message_type_support_t;
    pub fn unique_identifier_msgs__msg__UUID__create() -> *mut unique_identifier_msgs__msg__UUID;
    pub fn unique_identifier_msgs__msg__UUID__destroy(msg: *mut unique_identifier_msgs__msg__UUID);
    pub fn unique_identifier_msgs__msg__UUID__Sequence__init(
        array: *mut unique_identifier_msgs__msg__UUID__Sequence,
        size: usize,
    ) -> bool;
    pub fn unique_identifier_msgs__msg__UUID__Sequence__fini(
        array: *mut unique_identifier_msgs__msg__UUID__Sequence,
    );
    pub fn unique_identifier_msgs__msg__UUID__Sequence__create(
        size: usize,
    ) -> *mut unique_identifier_msgs__msg__UUID__Sequence;
    pub fn unique_identifier_msgs__msg__UUID__Sequence__destroy(
        array: *mut unique_identifier_msgs__msg__UUID__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__unique_identifier_msgs__msg__UUID(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__visualization_msgs__msg__ImageMarker(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__visualization_msgs__msg__InteractiveMarker(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__visualization_msgs__msg__InteractiveMarkerControl(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__visualization_msgs__msg__InteractiveMarkerFeedback(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__visualization_msgs__msg__InteractiveMarkerInit(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__visualization_msgs__msg__InteractiveMarkerPose(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__visualization_msgs__msg__InteractiveMarkerUpdate(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__visualization_msgs__msg__Marker(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__visualization_msgs__msg__MarkerArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__visualization_msgs__msg__MenuEntry(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__visualization_msgs__msg__MeshFile(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__visualization_msgs__msg__UVCoordinate(
    ) -> *const rosidl_message_type_support_t;
    pub fn visualization_msgs__msg__ImageMarker__create(
    ) -> *mut visualization_msgs__msg__ImageMarker;
    pub fn visualization_msgs__msg__ImageMarker__destroy(
        msg: *mut visualization_msgs__msg__ImageMarker,
    );
    pub fn visualization_msgs__msg__ImageMarker__Sequence__init(
        array: *mut visualization_msgs__msg__ImageMarker__Sequence,
        size: usize,
    ) -> bool;
    pub fn visualization_msgs__msg__ImageMarker__Sequence__fini(
        array: *mut visualization_msgs__msg__ImageMarker__Sequence,
    );
    pub fn visualization_msgs__msg__ImageMarker__Sequence__create(
        size: usize,
    ) -> *mut visualization_msgs__msg__ImageMarker__Sequence;
    pub fn visualization_msgs__msg__ImageMarker__Sequence__destroy(
        array: *mut visualization_msgs__msg__ImageMarker__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__visualization_msgs__msg__ImageMarker(
    ) -> *const rosidl_message_type_support_t;
    pub fn visualization_msgs__msg__InteractiveMarker__create(
    ) -> *mut visualization_msgs__msg__InteractiveMarker;
    pub fn visualization_msgs__msg__InteractiveMarker__destroy(
        msg: *mut visualization_msgs__msg__InteractiveMarker,
    );
    pub fn visualization_msgs__msg__InteractiveMarker__Sequence__init(
        array: *mut visualization_msgs__msg__InteractiveMarker__Sequence,
        size: usize,
    ) -> bool;
    pub fn visualization_msgs__msg__InteractiveMarker__Sequence__fini(
        array: *mut visualization_msgs__msg__InteractiveMarker__Sequence,
    );
    pub fn visualization_msgs__msg__InteractiveMarker__Sequence__create(
        size: usize,
    ) -> *mut visualization_msgs__msg__InteractiveMarker__Sequence;
    pub fn visualization_msgs__msg__InteractiveMarker__Sequence__destroy(
        array: *mut visualization_msgs__msg__InteractiveMarker__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__visualization_msgs__msg__InteractiveMarker(
    ) -> *const rosidl_message_type_support_t;
    pub fn visualization_msgs__msg__InteractiveMarkerControl__create(
    ) -> *mut visualization_msgs__msg__InteractiveMarkerControl;
    pub fn visualization_msgs__msg__InteractiveMarkerControl__destroy(
        msg: *mut visualization_msgs__msg__InteractiveMarkerControl,
    );
    pub fn visualization_msgs__msg__InteractiveMarkerControl__Sequence__init(
        array: *mut visualization_msgs__msg__InteractiveMarkerControl__Sequence,
        size: usize,
    ) -> bool;
    pub fn visualization_msgs__msg__InteractiveMarkerControl__Sequence__fini(
        array: *mut visualization_msgs__msg__InteractiveMarkerControl__Sequence,
    );
    pub fn visualization_msgs__msg__InteractiveMarkerControl__Sequence__create(
        size: usize,
    ) -> *mut visualization_msgs__msg__InteractiveMarkerControl__Sequence;
    pub fn visualization_msgs__msg__InteractiveMarkerControl__Sequence__destroy(
        array: *mut visualization_msgs__msg__InteractiveMarkerControl__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__visualization_msgs__msg__InteractiveMarkerControl(
    ) -> *const rosidl_message_type_support_t;
    pub fn visualization_msgs__msg__InteractiveMarkerFeedback__create(
    ) -> *mut visualization_msgs__msg__InteractiveMarkerFeedback;
    pub fn visualization_msgs__msg__InteractiveMarkerFeedback__destroy(
        msg: *mut visualization_msgs__msg__InteractiveMarkerFeedback,
    );
    pub fn visualization_msgs__msg__InteractiveMarkerFeedback__Sequence__init(
        array: *mut visualization_msgs__msg__InteractiveMarkerFeedback__Sequence,
        size: usize,
    ) -> bool;
    pub fn visualization_msgs__msg__InteractiveMarkerFeedback__Sequence__fini(
        array: *mut visualization_msgs__msg__InteractiveMarkerFeedback__Sequence,
    );
    pub fn visualization_msgs__msg__InteractiveMarkerFeedback__Sequence__create(
        size: usize,
    ) -> *mut visualization_msgs__msg__InteractiveMarkerFeedback__Sequence;
    pub fn visualization_msgs__msg__InteractiveMarkerFeedback__Sequence__destroy(
        array: *mut visualization_msgs__msg__InteractiveMarkerFeedback__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__visualization_msgs__msg__InteractiveMarkerFeedback(
    ) -> *const rosidl_message_type_support_t;
    pub fn visualization_msgs__msg__InteractiveMarkerInit__create(
    ) -> *mut visualization_msgs__msg__InteractiveMarkerInit;
    pub fn visualization_msgs__msg__InteractiveMarkerInit__destroy(
        msg: *mut visualization_msgs__msg__InteractiveMarkerInit,
    );
    pub fn visualization_msgs__msg__InteractiveMarkerInit__Sequence__init(
        array: *mut visualization_msgs__msg__InteractiveMarkerInit__Sequence,
        size: usize,
    ) -> bool;
    pub fn visualization_msgs__msg__InteractiveMarkerInit__Sequence__fini(
        array: *mut visualization_msgs__msg__InteractiveMarkerInit__Sequence,
    );
    pub fn visualization_msgs__msg__InteractiveMarkerInit__Sequence__create(
        size: usize,
    ) -> *mut visualization_msgs__msg__InteractiveMarkerInit__Sequence;
    pub fn visualization_msgs__msg__InteractiveMarkerInit__Sequence__destroy(
        array: *mut visualization_msgs__msg__InteractiveMarkerInit__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__visualization_msgs__msg__InteractiveMarkerInit(
    ) -> *const rosidl_message_type_support_t;
    pub fn visualization_msgs__msg__InteractiveMarkerPose__create(
    ) -> *mut visualization_msgs__msg__InteractiveMarkerPose;
    pub fn visualization_msgs__msg__InteractiveMarkerPose__destroy(
        msg: *mut visualization_msgs__msg__InteractiveMarkerPose,
    );
    pub fn visualization_msgs__msg__InteractiveMarkerPose__Sequence__init(
        array: *mut visualization_msgs__msg__InteractiveMarkerPose__Sequence,
        size: usize,
    ) -> bool;
    pub fn visualization_msgs__msg__InteractiveMarkerPose__Sequence__fini(
        array: *mut visualization_msgs__msg__InteractiveMarkerPose__Sequence,
    );
    pub fn visualization_msgs__msg__InteractiveMarkerPose__Sequence__create(
        size: usize,
    ) -> *mut visualization_msgs__msg__InteractiveMarkerPose__Sequence;
    pub fn visualization_msgs__msg__InteractiveMarkerPose__Sequence__destroy(
        array: *mut visualization_msgs__msg__InteractiveMarkerPose__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__visualization_msgs__msg__InteractiveMarkerPose(
    ) -> *const rosidl_message_type_support_t;
    pub fn visualization_msgs__msg__InteractiveMarkerUpdate__create(
    ) -> *mut visualization_msgs__msg__InteractiveMarkerUpdate;
    pub fn visualization_msgs__msg__InteractiveMarkerUpdate__destroy(
        msg: *mut visualization_msgs__msg__InteractiveMarkerUpdate,
    );
    pub fn visualization_msgs__msg__InteractiveMarkerUpdate__Sequence__init(
        array: *mut visualization_msgs__msg__InteractiveMarkerUpdate__Sequence,
        size: usize,
    ) -> bool;
    pub fn visualization_msgs__msg__InteractiveMarkerUpdate__Sequence__fini(
        array: *mut visualization_msgs__msg__InteractiveMarkerUpdate__Sequence,
    );
    pub fn visualization_msgs__msg__InteractiveMarkerUpdate__Sequence__create(
        size: usize,
    ) -> *mut visualization_msgs__msg__InteractiveMarkerUpdate__Sequence;
    pub fn visualization_msgs__msg__InteractiveMarkerUpdate__Sequence__destroy(
        array: *mut visualization_msgs__msg__InteractiveMarkerUpdate__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__visualization_msgs__msg__InteractiveMarkerUpdate(
    ) -> *const rosidl_message_type_support_t;
    pub fn visualization_msgs__msg__Marker__create() -> *mut visualization_msgs__msg__Marker;
    pub fn visualization_msgs__msg__Marker__destroy(msg: *mut visualization_msgs__msg__Marker);
    pub fn visualization_msgs__msg__Marker__Sequence__init(
        array: *mut visualization_msgs__msg__Marker__Sequence,
        size: usize,
    ) -> bool;
    pub fn visualization_msgs__msg__Marker__Sequence__fini(
        array: *mut visualization_msgs__msg__Marker__Sequence,
    );
    pub fn visualization_msgs__msg__Marker__Sequence__create(
        size: usize,
    ) -> *mut visualization_msgs__msg__Marker__Sequence;
    pub fn visualization_msgs__msg__Marker__Sequence__destroy(
        array: *mut visualization_msgs__msg__Marker__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__visualization_msgs__msg__Marker(
    ) -> *const rosidl_message_type_support_t;
    pub fn visualization_msgs__msg__MarkerArray__create(
    ) -> *mut visualization_msgs__msg__MarkerArray;
    pub fn visualization_msgs__msg__MarkerArray__destroy(
        msg: *mut visualization_msgs__msg__MarkerArray,
    );
    pub fn visualization_msgs__msg__MarkerArray__Sequence__init(
        array: *mut visualization_msgs__msg__MarkerArray__Sequence,
        size: usize,
    ) -> bool;
    pub fn visualization_msgs__msg__MarkerArray__Sequence__fini(
        array: *mut visualization_msgs__msg__MarkerArray__Sequence,
    );
    pub fn visualization_msgs__msg__MarkerArray__Sequence__create(
        size: usize,
    ) -> *mut visualization_msgs__msg__MarkerArray__Sequence;
    pub fn visualization_msgs__msg__MarkerArray__Sequence__destroy(
        array: *mut visualization_msgs__msg__MarkerArray__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__visualization_msgs__msg__MarkerArray(
    ) -> *const rosidl_message_type_support_t;
    pub fn visualization_msgs__msg__MenuEntry__create() -> *mut visualization_msgs__msg__MenuEntry;
    pub fn visualization_msgs__msg__MenuEntry__destroy(
        msg: *mut visualization_msgs__msg__MenuEntry,
    );
    pub fn visualization_msgs__msg__MenuEntry__Sequence__init(
        array: *mut visualization_msgs__msg__MenuEntry__Sequence,
        size: usize,
    ) -> bool;
    pub fn visualization_msgs__msg__MenuEntry__Sequence__fini(
        array: *mut visualization_msgs__msg__MenuEntry__Sequence,
    );
    pub fn visualization_msgs__msg__MenuEntry__Sequence__create(
        size: usize,
    ) -> *mut visualization_msgs__msg__MenuEntry__Sequence;
    pub fn visualization_msgs__msg__MenuEntry__Sequence__destroy(
        array: *mut visualization_msgs__msg__MenuEntry__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__visualization_msgs__msg__MenuEntry(
    ) -> *const rosidl_message_type_support_t;
    pub fn visualization_msgs__msg__MeshFile__create() -> *mut visualization_msgs__msg__MeshFile;
    pub fn visualization_msgs__msg__MeshFile__destroy(msg: *mut visualization_msgs__msg__MeshFile);
    pub fn visualization_msgs__msg__MeshFile__Sequence__init(
        array: *mut visualization_msgs__msg__MeshFile__Sequence,
        size: usize,
    ) -> bool;
    pub fn visualization_msgs__msg__MeshFile__Sequence__fini(
        array: *mut visualization_msgs__msg__MeshFile__Sequence,
    );
    pub fn visualization_msgs__msg__MeshFile__Sequence__create(
        size: usize,
    ) -> *mut visualization_msgs__msg__MeshFile__Sequence;
    pub fn visualization_msgs__msg__MeshFile__Sequence__destroy(
        array: *mut visualization_msgs__msg__MeshFile__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__visualization_msgs__msg__MeshFile(
    ) -> *const rosidl_message_type_support_t;
    pub fn visualization_msgs__msg__UVCoordinate__create(
    ) -> *mut visualization_msgs__msg__UVCoordinate;
    pub fn visualization_msgs__msg__UVCoordinate__destroy(
        msg: *mut visualization_msgs__msg__UVCoordinate,
    );
    pub fn visualization_msgs__msg__UVCoordinate__Sequence__init(
        array: *mut visualization_msgs__msg__UVCoordinate__Sequence,
        size: usize,
    ) -> bool;
    pub fn visualization_msgs__msg__UVCoordinate__Sequence__fini(
        array: *mut visualization_msgs__msg__UVCoordinate__Sequence,
    );
    pub fn visualization_msgs__msg__UVCoordinate__Sequence__create(
        size: usize,
    ) -> *mut visualization_msgs__msg__UVCoordinate__Sequence;
    pub fn visualization_msgs__msg__UVCoordinate__Sequence__destroy(
        array: *mut visualization_msgs__msg__UVCoordinate__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__visualization_msgs__msg__UVCoordinate(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__visualization_msgs__srv__GetInteractiveMarkers_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_message_type_support_handle__visualization_msgs__srv__GetInteractiveMarkers_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_introspection_c__get_service_type_support_handle__visualization_msgs__srv__GetInteractiveMarkers(
    ) -> *const rosidl_service_type_support_t;
    pub fn visualization_msgs__srv__GetInteractiveMarkers_Request__create(
    ) -> *mut visualization_msgs__srv__GetInteractiveMarkers_Request;
    pub fn visualization_msgs__srv__GetInteractiveMarkers_Request__destroy(
        msg: *mut visualization_msgs__srv__GetInteractiveMarkers_Request,
    );
    pub fn visualization_msgs__srv__GetInteractiveMarkers_Request__Sequence__init(
        array: *mut visualization_msgs__srv__GetInteractiveMarkers_Request__Sequence,
        size: usize,
    ) -> bool;
    pub fn visualization_msgs__srv__GetInteractiveMarkers_Request__Sequence__fini(
        array: *mut visualization_msgs__srv__GetInteractiveMarkers_Request__Sequence,
    );
    pub fn visualization_msgs__srv__GetInteractiveMarkers_Request__Sequence__create(
        size: usize,
    ) -> *mut visualization_msgs__srv__GetInteractiveMarkers_Request__Sequence;
    pub fn visualization_msgs__srv__GetInteractiveMarkers_Request__Sequence__destroy(
        array: *mut visualization_msgs__srv__GetInteractiveMarkers_Request__Sequence,
    );
    pub fn visualization_msgs__srv__GetInteractiveMarkers_Response__create(
    ) -> *mut visualization_msgs__srv__GetInteractiveMarkers_Response;
    pub fn visualization_msgs__srv__GetInteractiveMarkers_Response__destroy(
        msg: *mut visualization_msgs__srv__GetInteractiveMarkers_Response,
    );
    pub fn visualization_msgs__srv__GetInteractiveMarkers_Response__Sequence__init(
        array: *mut visualization_msgs__srv__GetInteractiveMarkers_Response__Sequence,
        size: usize,
    ) -> bool;
    pub fn visualization_msgs__srv__GetInteractiveMarkers_Response__Sequence__fini(
        array: *mut visualization_msgs__srv__GetInteractiveMarkers_Response__Sequence,
    );
    pub fn visualization_msgs__srv__GetInteractiveMarkers_Response__Sequence__create(
        size: usize,
    ) -> *mut visualization_msgs__srv__GetInteractiveMarkers_Response__Sequence;
    pub fn visualization_msgs__srv__GetInteractiveMarkers_Response__Sequence__destroy(
        array: *mut visualization_msgs__srv__GetInteractiveMarkers_Response__Sequence,
    );
    pub fn rosidl_typesupport_c__get_message_type_support_handle__visualization_msgs__srv__GetInteractiveMarkers_Request(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_message_type_support_handle__visualization_msgs__srv__GetInteractiveMarkers_Response(
    ) -> *const rosidl_message_type_support_t;
    pub fn rosidl_typesupport_c__get_service_type_support_handle__visualization_msgs__srv__GetInteractiveMarkers(
    ) -> *const rosidl_service_type_support_t;
}