implot-rs/implot-sys/src/bindings.rs

/* automatically generated by rust-bindgen 0.55.1 */

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImDrawListSharedData {
    _unused: [u8; 0],
}
pub type ImGuiCond = ::std::os::raw::c_int;
pub type ImGuiMouseButton = ::std::os::raw::c_int;
pub type ImDrawListFlags = ::std::os::raw::c_int;
pub type ImGuiDragDropFlags = ::std::os::raw::c_int;
pub type ImGuiKeyModFlags = ::std::os::raw::c_int;
pub type ImTextureID = *mut ::std::os::raw::c_void;
pub type ImU32 = ::std::os::raw::c_uint;
pub type ImDrawCallback = ::std::option::Option<
    unsafe extern "C" fn(parent_list: *const ImDrawList, cmd: *const ImDrawCmd),
>;
pub type ImDrawIdx = ::std::os::raw::c_ushort;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImDrawVert {
    pub Size: ::std::os::raw::c_int,
    pub Capacity: ::std::os::raw::c_int,
    pub Data: *mut ImDrawVert,
}
#[test]
fn bindgen_test_layout_ImVector_ImDrawVert() {
    assert_eq!(
        ::std::mem::size_of::<ImVector_ImDrawVert>(),
        16usize,
        concat!("Size of: ", stringify!(ImVector_ImDrawVert))
    );
    assert_eq!(
        ::std::mem::align_of::<ImVector_ImDrawVert>(),
        8usize,
        concat!("Alignment of ", stringify!(ImVector_ImDrawVert))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVector_ImDrawVert>())).Size as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(ImVector_ImDrawVert),
            "::",
            stringify!(Size)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVector_ImDrawVert>())).Capacity as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(ImVector_ImDrawVert),
            "::",
            stringify!(Capacity)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVector_ImDrawVert>())).Data as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(ImVector_ImDrawVert),
            "::",
            stringify!(Data)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImDrawChannel {
    pub Size: ::std::os::raw::c_int,
    pub Capacity: ::std::os::raw::c_int,
    pub Data: *mut ImDrawChannel,
}
#[test]
fn bindgen_test_layout_ImVector_ImDrawChannel() {
    assert_eq!(
        ::std::mem::size_of::<ImVector_ImDrawChannel>(),
        16usize,
        concat!("Size of: ", stringify!(ImVector_ImDrawChannel))
    );
    assert_eq!(
        ::std::mem::align_of::<ImVector_ImDrawChannel>(),
        8usize,
        concat!("Alignment of ", stringify!(ImVector_ImDrawChannel))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVector_ImDrawChannel>())).Size as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(ImVector_ImDrawChannel),
            "::",
            stringify!(Size)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVector_ImDrawChannel>())).Capacity as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(ImVector_ImDrawChannel),
            "::",
            stringify!(Capacity)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVector_ImDrawChannel>())).Data as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(ImVector_ImDrawChannel),
            "::",
            stringify!(Data)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImTextureID {
    pub Size: ::std::os::raw::c_int,
    pub Capacity: ::std::os::raw::c_int,
    pub Data: *mut ImTextureID,
}
#[test]
fn bindgen_test_layout_ImVector_ImTextureID() {
    assert_eq!(
        ::std::mem::size_of::<ImVector_ImTextureID>(),
        16usize,
        concat!("Size of: ", stringify!(ImVector_ImTextureID))
    );
    assert_eq!(
        ::std::mem::align_of::<ImVector_ImTextureID>(),
        8usize,
        concat!("Alignment of ", stringify!(ImVector_ImTextureID))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVector_ImTextureID>())).Size as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(ImVector_ImTextureID),
            "::",
            stringify!(Size)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVector_ImTextureID>())).Capacity as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(ImVector_ImTextureID),
            "::",
            stringify!(Capacity)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVector_ImTextureID>())).Data as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(ImVector_ImTextureID),
            "::",
            stringify!(Data)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImDrawCmd {
    pub Size: ::std::os::raw::c_int,
    pub Capacity: ::std::os::raw::c_int,
    pub Data: *mut ImDrawCmd,
}
#[test]
fn bindgen_test_layout_ImVector_ImDrawCmd() {
    assert_eq!(
        ::std::mem::size_of::<ImVector_ImDrawCmd>(),
        16usize,
        concat!("Size of: ", stringify!(ImVector_ImDrawCmd))
    );
    assert_eq!(
        ::std::mem::align_of::<ImVector_ImDrawCmd>(),
        8usize,
        concat!("Alignment of ", stringify!(ImVector_ImDrawCmd))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVector_ImDrawCmd>())).Size as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(ImVector_ImDrawCmd),
            "::",
            stringify!(Size)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVector_ImDrawCmd>())).Capacity as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(ImVector_ImDrawCmd),
            "::",
            stringify!(Capacity)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVector_ImDrawCmd>())).Data as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(ImVector_ImDrawCmd),
            "::",
            stringify!(Data)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImVec4 {
    pub Size: ::std::os::raw::c_int,
    pub Capacity: ::std::os::raw::c_int,
    pub Data: *mut ImVec4,
}
#[test]
fn bindgen_test_layout_ImVector_ImVec4() {
    assert_eq!(
        ::std::mem::size_of::<ImVector_ImVec4>(),
        16usize,
        concat!("Size of: ", stringify!(ImVector_ImVec4))
    );
    assert_eq!(
        ::std::mem::align_of::<ImVector_ImVec4>(),
        8usize,
        concat!("Alignment of ", stringify!(ImVector_ImVec4))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVector_ImVec4>())).Size as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(ImVector_ImVec4),
            "::",
            stringify!(Size)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVector_ImVec4>())).Capacity as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(ImVector_ImVec4),
            "::",
            stringify!(Capacity)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVector_ImVec4>())).Data as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(ImVector_ImVec4),
            "::",
            stringify!(Data)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImDrawIdx {
    pub Size: ::std::os::raw::c_int,
    pub Capacity: ::std::os::raw::c_int,
    pub Data: *mut ImDrawIdx,
}
#[test]
fn bindgen_test_layout_ImVector_ImDrawIdx() {
    assert_eq!(
        ::std::mem::size_of::<ImVector_ImDrawIdx>(),
        16usize,
        concat!("Size of: ", stringify!(ImVector_ImDrawIdx))
    );
    assert_eq!(
        ::std::mem::align_of::<ImVector_ImDrawIdx>(),
        8usize,
        concat!("Alignment of ", stringify!(ImVector_ImDrawIdx))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVector_ImDrawIdx>())).Size as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(ImVector_ImDrawIdx),
            "::",
            stringify!(Size)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVector_ImDrawIdx>())).Capacity as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(ImVector_ImDrawIdx),
            "::",
            stringify!(Capacity)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVector_ImDrawIdx>())).Data as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(ImVector_ImDrawIdx),
            "::",
            stringify!(Data)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImVec2 {
    pub Size: ::std::os::raw::c_int,
    pub Capacity: ::std::os::raw::c_int,
    pub Data: *mut ImVec2,
}
#[test]
fn bindgen_test_layout_ImVector_ImVec2() {
    assert_eq!(
        ::std::mem::size_of::<ImVector_ImVec2>(),
        16usize,
        concat!("Size of: ", stringify!(ImVector_ImVec2))
    );
    assert_eq!(
        ::std::mem::align_of::<ImVector_ImVec2>(),
        8usize,
        concat!("Alignment of ", stringify!(ImVector_ImVec2))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVector_ImVec2>())).Size as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(ImVector_ImVec2),
            "::",
            stringify!(Size)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVector_ImVec2>())).Capacity as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(ImVector_ImVec2),
            "::",
            stringify!(Capacity)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVector_ImVec2>())).Data as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(ImVector_ImVec2),
            "::",
            stringify!(Data)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVec2 {
    pub x: f32,
    pub y: f32,
}
#[test]
fn bindgen_test_layout_ImVec2() {
    assert_eq!(
        ::std::mem::size_of::<ImVec2>(),
        8usize,
        concat!("Size of: ", stringify!(ImVec2))
    );
    assert_eq!(
        ::std::mem::align_of::<ImVec2>(),
        4usize,
        concat!("Alignment of ", stringify!(ImVec2))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVec2>())).x as *const _ as usize },
        0usize,
        concat!("Offset of field: ", stringify!(ImVec2), "::", stringify!(x))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVec2>())).y as *const _ as usize },
        4usize,
        concat!("Offset of field: ", stringify!(ImVec2), "::", stringify!(y))
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVec4 {
    pub x: f32,
    pub y: f32,
    pub z: f32,
    pub w: f32,
}
#[test]
fn bindgen_test_layout_ImVec4() {
    assert_eq!(
        ::std::mem::size_of::<ImVec4>(),
        16usize,
        concat!("Size of: ", stringify!(ImVec4))
    );
    assert_eq!(
        ::std::mem::align_of::<ImVec4>(),
        4usize,
        concat!("Alignment of ", stringify!(ImVec4))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVec4>())).x as *const _ as usize },
        0usize,
        concat!("Offset of field: ", stringify!(ImVec4), "::", stringify!(x))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVec4>())).y as *const _ as usize },
        4usize,
        concat!("Offset of field: ", stringify!(ImVec4), "::", stringify!(y))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVec4>())).z as *const _ as usize },
        8usize,
        concat!("Offset of field: ", stringify!(ImVec4), "::", stringify!(z))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImVec4>())).w as *const _ as usize },
        12usize,
        concat!("Offset of field: ", stringify!(ImVec4), "::", stringify!(w))
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImDrawCmd {
    pub ClipRect: ImVec4,
    pub TextureId: ImTextureID,
    pub VtxOffset: ::std::os::raw::c_uint,
    pub IdxOffset: ::std::os::raw::c_uint,
    pub ElemCount: ::std::os::raw::c_uint,
    pub UserCallback: ImDrawCallback,
    pub UserCallbackData: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_ImDrawCmd() {
    assert_eq!(
        ::std::mem::size_of::<ImDrawCmd>(),
        56usize,
        concat!("Size of: ", stringify!(ImDrawCmd))
    );
    assert_eq!(
        ::std::mem::align_of::<ImDrawCmd>(),
        8usize,
        concat!("Alignment of ", stringify!(ImDrawCmd))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawCmd>())).ClipRect as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawCmd),
            "::",
            stringify!(ClipRect)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawCmd>())).TextureId as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawCmd),
            "::",
            stringify!(TextureId)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawCmd>())).VtxOffset as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawCmd),
            "::",
            stringify!(VtxOffset)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawCmd>())).IdxOffset as *const _ as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawCmd),
            "::",
            stringify!(IdxOffset)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawCmd>())).ElemCount as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawCmd),
            "::",
            stringify!(ElemCount)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawCmd>())).UserCallback as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawCmd),
            "::",
            stringify!(UserCallback)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawCmd>())).UserCallbackData as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawCmd),
            "::",
            stringify!(UserCallbackData)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImDrawVert {
    pub pos: ImVec2,
    pub uv: ImVec2,
    pub col: ImU32,
}
#[test]
fn bindgen_test_layout_ImDrawVert() {
    assert_eq!(
        ::std::mem::size_of::<ImDrawVert>(),
        20usize,
        concat!("Size of: ", stringify!(ImDrawVert))
    );
    assert_eq!(
        ::std::mem::align_of::<ImDrawVert>(),
        4usize,
        concat!("Alignment of ", stringify!(ImDrawVert))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawVert>())).pos as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawVert),
            "::",
            stringify!(pos)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawVert>())).uv as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawVert),
            "::",
            stringify!(uv)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawVert>())).col as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawVert),
            "::",
            stringify!(col)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImDrawChannel {
    pub _CmdBuffer: ImVector_ImDrawCmd,
    pub _IdxBuffer: ImVector_ImDrawIdx,
}
#[test]
fn bindgen_test_layout_ImDrawChannel() {
    assert_eq!(
        ::std::mem::size_of::<ImDrawChannel>(),
        32usize,
        concat!("Size of: ", stringify!(ImDrawChannel))
    );
    assert_eq!(
        ::std::mem::align_of::<ImDrawChannel>(),
        8usize,
        concat!("Alignment of ", stringify!(ImDrawChannel))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawChannel>()))._CmdBuffer as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawChannel),
            "::",
            stringify!(_CmdBuffer)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawChannel>()))._IdxBuffer as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawChannel),
            "::",
            stringify!(_IdxBuffer)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImDrawListSplitter {
    pub _Current: ::std::os::raw::c_int,
    pub _Count: ::std::os::raw::c_int,
    pub _Channels: ImVector_ImDrawChannel,
}
#[test]
fn bindgen_test_layout_ImDrawListSplitter() {
    assert_eq!(
        ::std::mem::size_of::<ImDrawListSplitter>(),
        24usize,
        concat!("Size of: ", stringify!(ImDrawListSplitter))
    );
    assert_eq!(
        ::std::mem::align_of::<ImDrawListSplitter>(),
        8usize,
        concat!("Alignment of ", stringify!(ImDrawListSplitter))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawListSplitter>()))._Current as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawListSplitter),
            "::",
            stringify!(_Current)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawListSplitter>()))._Count as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawListSplitter),
            "::",
            stringify!(_Count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawListSplitter>()))._Channels as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawListSplitter),
            "::",
            stringify!(_Channels)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImDrawList {
    pub CmdBuffer: ImVector_ImDrawCmd,
    pub IdxBuffer: ImVector_ImDrawIdx,
    pub VtxBuffer: ImVector_ImDrawVert,
    pub Flags: ImDrawListFlags,
    pub _Data: *const ImDrawListSharedData,
    pub _OwnerName: *const ::std::os::raw::c_char,
    pub _VtxCurrentIdx: ::std::os::raw::c_uint,
    pub _VtxWritePtr: *mut ImDrawVert,
    pub _IdxWritePtr: *mut ImDrawIdx,
    pub _ClipRectStack: ImVector_ImVec4,
    pub _TextureIdStack: ImVector_ImTextureID,
    pub _Path: ImVector_ImVec2,
    pub _CmdHeader: ImDrawCmd,
    pub _Splitter: ImDrawListSplitter,
}
#[test]
fn bindgen_test_layout_ImDrawList() {
    assert_eq!(
        ::std::mem::size_of::<ImDrawList>(),
        224usize,
        concat!("Size of: ", stringify!(ImDrawList))
    );
    assert_eq!(
        ::std::mem::align_of::<ImDrawList>(),
        8usize,
        concat!("Alignment of ", stringify!(ImDrawList))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawList>())).CmdBuffer as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawList),
            "::",
            stringify!(CmdBuffer)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawList>())).IdxBuffer as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawList),
            "::",
            stringify!(IdxBuffer)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawList>())).VtxBuffer as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawList),
            "::",
            stringify!(VtxBuffer)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawList>())).Flags as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawList),
            "::",
            stringify!(Flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawList>()))._Data as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawList),
            "::",
            stringify!(_Data)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawList>()))._OwnerName as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawList),
            "::",
            stringify!(_OwnerName)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawList>()))._VtxCurrentIdx as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawList),
            "::",
            stringify!(_VtxCurrentIdx)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawList>()))._VtxWritePtr as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawList),
            "::",
            stringify!(_VtxWritePtr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawList>()))._IdxWritePtr as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawList),
            "::",
            stringify!(_IdxWritePtr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawList>()))._ClipRectStack as *const _ as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawList),
            "::",
            stringify!(_ClipRectStack)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawList>()))._TextureIdStack as *const _ as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawList),
            "::",
            stringify!(_TextureIdStack)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawList>()))._Path as *const _ as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawList),
            "::",
            stringify!(_Path)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawList>()))._CmdHeader as *const _ as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawList),
            "::",
            stringify!(_CmdHeader)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImDrawList>()))._Splitter as *const _ as usize },
        200usize,
        concat!(
            "Offset of field: ",
            stringify!(ImDrawList),
            "::",
            stringify!(_Splitter)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImPlotContext {
    _unused: [u8; 0],
}
pub type ImPlotFlags = ::std::os::raw::c_int;
pub type ImPlotAxisFlags = ::std::os::raw::c_int;
pub type ImPlotCol = ::std::os::raw::c_int;
pub type ImPlotStyleVar = ::std::os::raw::c_int;
pub type ImPlotMarker = ::std::os::raw::c_int;
pub type ImPlotColormap = ::std::os::raw::c_int;
pub const ImPlotFlags__ImPlotFlags_None: ImPlotFlags_ = 0;
pub const ImPlotFlags__ImPlotFlags_NoLegend: ImPlotFlags_ = 1;
pub const ImPlotFlags__ImPlotFlags_NoMenus: ImPlotFlags_ = 2;
pub const ImPlotFlags__ImPlotFlags_NoBoxSelect: ImPlotFlags_ = 4;
pub const ImPlotFlags__ImPlotFlags_NoMousePos: ImPlotFlags_ = 8;
pub const ImPlotFlags__ImPlotFlags_NoHighlight: ImPlotFlags_ = 16;
pub const ImPlotFlags__ImPlotFlags_NoChild: ImPlotFlags_ = 32;
pub const ImPlotFlags__ImPlotFlags_YAxis2: ImPlotFlags_ = 64;
pub const ImPlotFlags__ImPlotFlags_YAxis3: ImPlotFlags_ = 128;
pub const ImPlotFlags__ImPlotFlags_Query: ImPlotFlags_ = 256;
pub const ImPlotFlags__ImPlotFlags_Crosshairs: ImPlotFlags_ = 512;
pub const ImPlotFlags__ImPlotFlags_AntiAliased: ImPlotFlags_ = 1024;
pub const ImPlotFlags__ImPlotFlags_CanvasOnly: ImPlotFlags_ = 15;
pub type ImPlotFlags_ = ::std::os::raw::c_int;
pub const ImPlotAxisFlags__ImPlotAxisFlags_None: ImPlotAxisFlags_ = 0;
pub const ImPlotAxisFlags__ImPlotAxisFlags_NoGridLines: ImPlotAxisFlags_ = 1;
pub const ImPlotAxisFlags__ImPlotAxisFlags_NoTickMarks: ImPlotAxisFlags_ = 2;
pub const ImPlotAxisFlags__ImPlotAxisFlags_NoTickLabels: ImPlotAxisFlags_ = 4;
pub const ImPlotAxisFlags__ImPlotAxisFlags_LogScale: ImPlotAxisFlags_ = 8;
pub const ImPlotAxisFlags__ImPlotAxisFlags_Time: ImPlotAxisFlags_ = 16;
pub const ImPlotAxisFlags__ImPlotAxisFlags_Invert: ImPlotAxisFlags_ = 32;
pub const ImPlotAxisFlags__ImPlotAxisFlags_LockMin: ImPlotAxisFlags_ = 64;
pub const ImPlotAxisFlags__ImPlotAxisFlags_LockMax: ImPlotAxisFlags_ = 128;
pub const ImPlotAxisFlags__ImPlotAxisFlags_Lock: ImPlotAxisFlags_ = 192;
pub const ImPlotAxisFlags__ImPlotAxisFlags_NoDecorations: ImPlotAxisFlags_ = 7;
pub type ImPlotAxisFlags_ = ::std::os::raw::c_int;
pub const ImPlotCol__ImPlotCol_Line: ImPlotCol_ = 0;
pub const ImPlotCol__ImPlotCol_Fill: ImPlotCol_ = 1;
pub const ImPlotCol__ImPlotCol_MarkerOutline: ImPlotCol_ = 2;
pub const ImPlotCol__ImPlotCol_MarkerFill: ImPlotCol_ = 3;
pub const ImPlotCol__ImPlotCol_ErrorBar: ImPlotCol_ = 4;
pub const ImPlotCol__ImPlotCol_FrameBg: ImPlotCol_ = 5;
pub const ImPlotCol__ImPlotCol_PlotBg: ImPlotCol_ = 6;
pub const ImPlotCol__ImPlotCol_PlotBorder: ImPlotCol_ = 7;
pub const ImPlotCol__ImPlotCol_LegendBg: ImPlotCol_ = 8;
pub const ImPlotCol__ImPlotCol_LegendBorder: ImPlotCol_ = 9;
pub const ImPlotCol__ImPlotCol_LegendText: ImPlotCol_ = 10;
pub const ImPlotCol__ImPlotCol_TitleText: ImPlotCol_ = 11;
pub const ImPlotCol__ImPlotCol_InlayText: ImPlotCol_ = 12;
pub const ImPlotCol__ImPlotCol_XAxis: ImPlotCol_ = 13;
pub const ImPlotCol__ImPlotCol_XAxisGrid: ImPlotCol_ = 14;
pub const ImPlotCol__ImPlotCol_YAxis: ImPlotCol_ = 15;
pub const ImPlotCol__ImPlotCol_YAxisGrid: ImPlotCol_ = 16;
pub const ImPlotCol__ImPlotCol_YAxis2: ImPlotCol_ = 17;
pub const ImPlotCol__ImPlotCol_YAxisGrid2: ImPlotCol_ = 18;
pub const ImPlotCol__ImPlotCol_YAxis3: ImPlotCol_ = 19;
pub const ImPlotCol__ImPlotCol_YAxisGrid3: ImPlotCol_ = 20;
pub const ImPlotCol__ImPlotCol_Selection: ImPlotCol_ = 21;
pub const ImPlotCol__ImPlotCol_Query: ImPlotCol_ = 22;
pub const ImPlotCol__ImPlotCol_Crosshairs: ImPlotCol_ = 23;
pub const ImPlotCol__ImPlotCol_COUNT: ImPlotCol_ = 24;
pub type ImPlotCol_ = ::std::os::raw::c_int;
pub const ImPlotStyleVar__ImPlotStyleVar_LineWeight: ImPlotStyleVar_ = 0;
pub const ImPlotStyleVar__ImPlotStyleVar_Marker: ImPlotStyleVar_ = 1;
pub const ImPlotStyleVar__ImPlotStyleVar_MarkerSize: ImPlotStyleVar_ = 2;
pub const ImPlotStyleVar__ImPlotStyleVar_MarkerWeight: ImPlotStyleVar_ = 3;
pub const ImPlotStyleVar__ImPlotStyleVar_FillAlpha: ImPlotStyleVar_ = 4;
pub const ImPlotStyleVar__ImPlotStyleVar_ErrorBarSize: ImPlotStyleVar_ = 5;
pub const ImPlotStyleVar__ImPlotStyleVar_ErrorBarWeight: ImPlotStyleVar_ = 6;
pub const ImPlotStyleVar__ImPlotStyleVar_DigitalBitHeight: ImPlotStyleVar_ = 7;
pub const ImPlotStyleVar__ImPlotStyleVar_DigitalBitGap: ImPlotStyleVar_ = 8;
pub const ImPlotStyleVar__ImPlotStyleVar_PlotBorderSize: ImPlotStyleVar_ = 9;
pub const ImPlotStyleVar__ImPlotStyleVar_MinorAlpha: ImPlotStyleVar_ = 10;
pub const ImPlotStyleVar__ImPlotStyleVar_MajorTickLen: ImPlotStyleVar_ = 11;
pub const ImPlotStyleVar__ImPlotStyleVar_MinorTickLen: ImPlotStyleVar_ = 12;
pub const ImPlotStyleVar__ImPlotStyleVar_MajorTickSize: ImPlotStyleVar_ = 13;
pub const ImPlotStyleVar__ImPlotStyleVar_MinorTickSize: ImPlotStyleVar_ = 14;
pub const ImPlotStyleVar__ImPlotStyleVar_MajorGridSize: ImPlotStyleVar_ = 15;
pub const ImPlotStyleVar__ImPlotStyleVar_MinorGridSize: ImPlotStyleVar_ = 16;
pub const ImPlotStyleVar__ImPlotStyleVar_PlotPadding: ImPlotStyleVar_ = 17;
pub const ImPlotStyleVar__ImPlotStyleVar_LabelPadding: ImPlotStyleVar_ = 18;
pub const ImPlotStyleVar__ImPlotStyleVar_LegendPadding: ImPlotStyleVar_ = 19;
pub const ImPlotStyleVar__ImPlotStyleVar_InfoPadding: ImPlotStyleVar_ = 20;
pub const ImPlotStyleVar__ImPlotStyleVar_PlotMinSize: ImPlotStyleVar_ = 21;
pub const ImPlotStyleVar__ImPlotStyleVar_COUNT: ImPlotStyleVar_ = 22;
pub type ImPlotStyleVar_ = ::std::os::raw::c_int;
pub const ImPlotMarker__ImPlotMarker_None: ImPlotMarker_ = -1;
pub const ImPlotMarker__ImPlotMarker_Circle: ImPlotMarker_ = 0;
pub const ImPlotMarker__ImPlotMarker_Square: ImPlotMarker_ = 1;
pub const ImPlotMarker__ImPlotMarker_Diamond: ImPlotMarker_ = 2;
pub const ImPlotMarker__ImPlotMarker_Up: ImPlotMarker_ = 3;
pub const ImPlotMarker__ImPlotMarker_Down: ImPlotMarker_ = 4;
pub const ImPlotMarker__ImPlotMarker_Left: ImPlotMarker_ = 5;
pub const ImPlotMarker__ImPlotMarker_Right: ImPlotMarker_ = 6;
pub const ImPlotMarker__ImPlotMarker_Cross: ImPlotMarker_ = 7;
pub const ImPlotMarker__ImPlotMarker_Plus: ImPlotMarker_ = 8;
pub const ImPlotMarker__ImPlotMarker_Asterisk: ImPlotMarker_ = 9;
pub const ImPlotMarker__ImPlotMarker_COUNT: ImPlotMarker_ = 10;
pub type ImPlotMarker_ = ::std::os::raw::c_int;
pub const ImPlotColormap__ImPlotColormap_Default: ImPlotColormap_ = 0;
pub const ImPlotColormap__ImPlotColormap_Deep: ImPlotColormap_ = 1;
pub const ImPlotColormap__ImPlotColormap_Dark: ImPlotColormap_ = 2;
pub const ImPlotColormap__ImPlotColormap_Pastel: ImPlotColormap_ = 3;
pub const ImPlotColormap__ImPlotColormap_Paired: ImPlotColormap_ = 4;
pub const ImPlotColormap__ImPlotColormap_Viridis: ImPlotColormap_ = 5;
pub const ImPlotColormap__ImPlotColormap_Plasma: ImPlotColormap_ = 6;
pub const ImPlotColormap__ImPlotColormap_Hot: ImPlotColormap_ = 7;
pub const ImPlotColormap__ImPlotColormap_Cool: ImPlotColormap_ = 8;
pub const ImPlotColormap__ImPlotColormap_Pink: ImPlotColormap_ = 9;
pub const ImPlotColormap__ImPlotColormap_Jet: ImPlotColormap_ = 10;
pub const ImPlotColormap__ImPlotColormap_COUNT: ImPlotColormap_ = 11;
pub type ImPlotColormap_ = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImPlotPoint {
    pub x: f64,
    pub y: f64,
}
#[test]
fn bindgen_test_layout_ImPlotPoint() {
    assert_eq!(
        ::std::mem::size_of::<ImPlotPoint>(),
        16usize,
        concat!("Size of: ", stringify!(ImPlotPoint))
    );
    assert_eq!(
        ::std::mem::align_of::<ImPlotPoint>(),
        8usize,
        concat!("Alignment of ", stringify!(ImPlotPoint))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotPoint>())).x as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotPoint),
            "::",
            stringify!(x)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotPoint>())).y as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotPoint),
            "::",
            stringify!(y)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImPlotRange {
    pub Min: f64,
    pub Max: f64,
}
#[test]
fn bindgen_test_layout_ImPlotRange() {
    assert_eq!(
        ::std::mem::size_of::<ImPlotRange>(),
        16usize,
        concat!("Size of: ", stringify!(ImPlotRange))
    );
    assert_eq!(
        ::std::mem::align_of::<ImPlotRange>(),
        8usize,
        concat!("Alignment of ", stringify!(ImPlotRange))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotRange>())).Min as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotRange),
            "::",
            stringify!(Min)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotRange>())).Max as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotRange),
            "::",
            stringify!(Max)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImPlotLimits {
    pub X: ImPlotRange,
    pub Y: ImPlotRange,
}
#[test]
fn bindgen_test_layout_ImPlotLimits() {
    assert_eq!(
        ::std::mem::size_of::<ImPlotLimits>(),
        32usize,
        concat!("Size of: ", stringify!(ImPlotLimits))
    );
    assert_eq!(
        ::std::mem::align_of::<ImPlotLimits>(),
        8usize,
        concat!("Alignment of ", stringify!(ImPlotLimits))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotLimits>())).X as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotLimits),
            "::",
            stringify!(X)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotLimits>())).Y as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotLimits),
            "::",
            stringify!(Y)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImPlotStyle {
    pub LineWeight: f32,
    pub Marker: ::std::os::raw::c_int,
    pub MarkerSize: f32,
    pub MarkerWeight: f32,
    pub FillAlpha: f32,
    pub ErrorBarSize: f32,
    pub ErrorBarWeight: f32,
    pub DigitalBitHeight: f32,
    pub DigitalBitGap: f32,
    pub PlotBorderSize: f32,
    pub MinorAlpha: f32,
    pub MajorTickLen: ImVec2,
    pub MinorTickLen: ImVec2,
    pub MajorTickSize: ImVec2,
    pub MinorTickSize: ImVec2,
    pub MajorGridSize: ImVec2,
    pub MinorGridSize: ImVec2,
    pub PlotPadding: ImVec2,
    pub LabelPadding: ImVec2,
    pub LegendPadding: ImVec2,
    pub InfoPadding: ImVec2,
    pub PlotMinSize: ImVec2,
    pub Colors: [ImVec4; 24usize],
    pub AntiAliasedLines: bool,
    pub UseLocalTime: bool,
}
#[test]
fn bindgen_test_layout_ImPlotStyle() {
    assert_eq!(
        ::std::mem::size_of::<ImPlotStyle>(),
        520usize,
        concat!("Size of: ", stringify!(ImPlotStyle))
    );
    assert_eq!(
        ::std::mem::align_of::<ImPlotStyle>(),
        4usize,
        concat!("Alignment of ", stringify!(ImPlotStyle))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).LineWeight as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotStyle),
            "::",
            stringify!(LineWeight)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).Marker as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotStyle),
            "::",
            stringify!(Marker)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).MarkerSize as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotStyle),
            "::",
            stringify!(MarkerSize)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).MarkerWeight as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotStyle),
            "::",
            stringify!(MarkerWeight)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).FillAlpha as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotStyle),
            "::",
            stringify!(FillAlpha)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).ErrorBarSize as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotStyle),
            "::",
            stringify!(ErrorBarSize)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).ErrorBarWeight as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotStyle),
            "::",
            stringify!(ErrorBarWeight)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).DigitalBitHeight as *const _ as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotStyle),
            "::",
            stringify!(DigitalBitHeight)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).DigitalBitGap as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotStyle),
            "::",
            stringify!(DigitalBitGap)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).PlotBorderSize as *const _ as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotStyle),
            "::",
            stringify!(PlotBorderSize)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).MinorAlpha as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotStyle),
            "::",
            stringify!(MinorAlpha)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).MajorTickLen as *const _ as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotStyle),
            "::",
            stringify!(MajorTickLen)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).MinorTickLen as *const _ as usize },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotStyle),
            "::",
            stringify!(MinorTickLen)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).MajorTickSize as *const _ as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotStyle),
            "::",
            stringify!(MajorTickSize)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).MinorTickSize as *const _ as usize },
        68usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotStyle),
            "::",
            stringify!(MinorTickSize)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).MajorGridSize as *const _ as usize },
        76usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotStyle),
            "::",
            stringify!(MajorGridSize)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).MinorGridSize as *const _ as usize },
        84usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotStyle),
            "::",
            stringify!(MinorGridSize)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).PlotPadding as *const _ as usize },
        92usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotStyle),
            "::",
            stringify!(PlotPadding)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).LabelPadding as *const _ as usize },
        100usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotStyle),
            "::",
            stringify!(LabelPadding)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).LegendPadding as *const _ as usize },
        108usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotStyle),
            "::",
            stringify!(LegendPadding)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).InfoPadding as *const _ as usize },
        116usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotStyle),
            "::",
            stringify!(InfoPadding)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).PlotMinSize as *const _ as usize },
        124usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotStyle),
            "::",
            stringify!(PlotMinSize)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).Colors as *const _ as usize },
        132usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotStyle),
            "::",
            stringify!(Colors)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).AntiAliasedLines as *const _ as usize },
        516usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotStyle),
            "::",
            stringify!(AntiAliasedLines)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).UseLocalTime as *const _ as usize },
        517usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotStyle),
            "::",
            stringify!(UseLocalTime)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImPlotInputMap {
    pub PanButton: ImGuiMouseButton,
    pub PanMod: ImGuiKeyModFlags,
    pub FitButton: ImGuiMouseButton,
    pub ContextMenuButton: ImGuiMouseButton,
    pub BoxSelectButton: ImGuiMouseButton,
    pub BoxSelectMod: ImGuiKeyModFlags,
    pub BoxSelectCancelButton: ImGuiMouseButton,
    pub QueryButton: ImGuiMouseButton,
    pub QueryMod: ImGuiKeyModFlags,
    pub QueryToggleMod: ImGuiKeyModFlags,
    pub HorizontalMod: ImGuiKeyModFlags,
    pub VerticalMod: ImGuiKeyModFlags,
}
#[test]
fn bindgen_test_layout_ImPlotInputMap() {
    assert_eq!(
        ::std::mem::size_of::<ImPlotInputMap>(),
        48usize,
        concat!("Size of: ", stringify!(ImPlotInputMap))
    );
    assert_eq!(
        ::std::mem::align_of::<ImPlotInputMap>(),
        4usize,
        concat!("Alignment of ", stringify!(ImPlotInputMap))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotInputMap>())).PanButton as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotInputMap),
            "::",
            stringify!(PanButton)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotInputMap>())).PanMod as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotInputMap),
            "::",
            stringify!(PanMod)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotInputMap>())).FitButton as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotInputMap),
            "::",
            stringify!(FitButton)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<ImPlotInputMap>())).ContextMenuButton as *const _ as usize
        },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotInputMap),
            "::",
            stringify!(ContextMenuButton)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotInputMap>())).BoxSelectButton as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotInputMap),
            "::",
            stringify!(BoxSelectButton)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotInputMap>())).BoxSelectMod as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotInputMap),
            "::",
            stringify!(BoxSelectMod)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<ImPlotInputMap>())).BoxSelectCancelButton as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotInputMap),
            "::",
            stringify!(BoxSelectCancelButton)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotInputMap>())).QueryButton as *const _ as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotInputMap),
            "::",
            stringify!(QueryButton)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotInputMap>())).QueryMod as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotInputMap),
            "::",
            stringify!(QueryMod)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotInputMap>())).QueryToggleMod as *const _ as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotInputMap),
            "::",
            stringify!(QueryToggleMod)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotInputMap>())).HorizontalMod as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotInputMap),
            "::",
            stringify!(HorizontalMod)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<ImPlotInputMap>())).VerticalMod as *const _ as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(ImPlotInputMap),
            "::",
            stringify!(VerticalMod)
        )
    );
}
extern "C" {
    pub fn ImPlotPoint_ImPlotPointNil() -> *mut ImPlotPoint;
}
extern "C" {
    pub fn ImPlotPoint_destroy(self_: *mut ImPlotPoint);
}
extern "C" {
    pub fn ImPlotPoint_ImPlotPointdouble(_x: f64, _y: f64) -> *mut ImPlotPoint;
}
extern "C" {
    pub fn ImPlotRange_ImPlotRangeNil() -> *mut ImPlotRange;
}
extern "C" {
    pub fn ImPlotRange_destroy(self_: *mut ImPlotRange);
}
extern "C" {
    pub fn ImPlotRange_ImPlotRangedouble(_min: f64, _max: f64) -> *mut ImPlotRange;
}
extern "C" {
    pub fn ImPlotRange_Contains(self_: *mut ImPlotRange, value: f64) -> bool;
}
extern "C" {
    pub fn ImPlotRange_Size(self_: *mut ImPlotRange) -> f64;
}
extern "C" {
    pub fn ImPlotLimits_ContainsPlotPoInt(self_: *mut ImPlotLimits, p: ImPlotPoint) -> bool;
}
extern "C" {
    pub fn ImPlotLimits_Containsdouble(self_: *mut ImPlotLimits, x: f64, y: f64) -> bool;
}
extern "C" {
    pub fn ImPlotStyle_ImPlotStyle() -> *mut ImPlotStyle;
}
extern "C" {
    pub fn ImPlotStyle_destroy(self_: *mut ImPlotStyle);
}
extern "C" {
    pub fn ImPlotInputMap_ImPlotInputMap() -> *mut ImPlotInputMap;
}
extern "C" {
    pub fn ImPlotInputMap_destroy(self_: *mut ImPlotInputMap);
}
extern "C" {
    pub fn ImPlot_CreateContext() -> *mut ImPlotContext;
}
extern "C" {
    pub fn ImPlot_DestroyContext(ctx: *mut ImPlotContext);
}
extern "C" {
    pub fn ImPlot_GetCurrentContext() -> *mut ImPlotContext;
}
extern "C" {
    pub fn ImPlot_SetCurrentContext(ctx: *mut ImPlotContext);
}
extern "C" {
    pub fn ImPlot_BeginPlot(
        title_id: *const ::std::os::raw::c_char,
        x_label: *const ::std::os::raw::c_char,
        y_label: *const ::std::os::raw::c_char,
        size: ImVec2,
        flags: ImPlotFlags,
        x_flags: ImPlotAxisFlags,
        y_flags: ImPlotAxisFlags,
        y2_flags: ImPlotAxisFlags,
        y3_flags: ImPlotAxisFlags,
    ) -> bool;
}
extern "C" {
    pub fn ImPlot_EndPlot();
}
extern "C" {
    pub fn ImPlot_PlotLineFloatPtrInt(
        label_id: *const ::std::os::raw::c_char,
        values: *const f32,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotLinedoublePtrInt(
        label_id: *const ::std::os::raw::c_char,
        values: *const f64,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotLineFloatPtrFloatPtr(
        label_id: *const ::std::os::raw::c_char,
        xs: *const f32,
        ys: *const f32,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotLinedoublePtrdoublePtr(
        label_id: *const ::std::os::raw::c_char,
        xs: *const f64,
        ys: *const f64,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotLineVec2Ptr(
        label_id: *const ::std::os::raw::c_char,
        data: *const ImVec2,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotLinePlotPoIntPtr(
        label_id: *const ::std::os::raw::c_char,
        data: *const ImPlotPoint,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotLineFnPlotPoIntPtr(
        label_id: *const ::std::os::raw::c_char,
        getter: ::std::option::Option<
            unsafe extern "C" fn(
                data: *mut ::std::os::raw::c_void,
                idx: ::std::os::raw::c_int,
            ) -> ImPlotPoint,
        >,
        data: *mut ::std::os::raw::c_void,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotScatterFloatPtrInt(
        label_id: *const ::std::os::raw::c_char,
        values: *const f32,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotScatterdoublePtrInt(
        label_id: *const ::std::os::raw::c_char,
        values: *const f64,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotScatterFloatPtrFloatPtr(
        label_id: *const ::std::os::raw::c_char,
        xs: *const f32,
        ys: *const f32,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotScatterdoublePtrdoublePtr(
        label_id: *const ::std::os::raw::c_char,
        xs: *const f64,
        ys: *const f64,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotScatterVec2Ptr(
        label_id: *const ::std::os::raw::c_char,
        data: *const ImVec2,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotScatterPlotPoIntPtr(
        label_id: *const ::std::os::raw::c_char,
        data: *const ImPlotPoint,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotScatterFnPlotPoIntPtr(
        label_id: *const ::std::os::raw::c_char,
        getter: ::std::option::Option<
            unsafe extern "C" fn(
                data: *mut ::std::os::raw::c_void,
                idx: ::std::os::raw::c_int,
            ) -> ImPlotPoint,
        >,
        data: *mut ::std::os::raw::c_void,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotShadedFloatPtrIntFloat(
        label_id: *const ::std::os::raw::c_char,
        values: *const f32,
        count: ::std::os::raw::c_int,
        y_ref: f32,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotShadeddoublePtrIntdouble(
        label_id: *const ::std::os::raw::c_char,
        values: *const f64,
        count: ::std::os::raw::c_int,
        y_ref: f64,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotShadedFloatPtrFloatPtrIntFloat(
        label_id: *const ::std::os::raw::c_char,
        xs: *const f32,
        ys: *const f32,
        count: ::std::os::raw::c_int,
        y_ref: f32,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotShadeddoublePtrdoublePtrIntdouble(
        label_id: *const ::std::os::raw::c_char,
        xs: *const f64,
        ys: *const f64,
        count: ::std::os::raw::c_int,
        y_ref: f64,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotShadedFloatPtrFloatPtrFloatPtr(
        label_id: *const ::std::os::raw::c_char,
        xs: *const f32,
        ys1: *const f32,
        ys2: *const f32,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotShadeddoublePtrdoublePtrdoublePtr(
        label_id: *const ::std::os::raw::c_char,
        xs: *const f64,
        ys1: *const f64,
        ys2: *const f64,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotShadedFnPlotPoIntPtr(
        label_id: *const ::std::os::raw::c_char,
        getter1: ::std::option::Option<
            unsafe extern "C" fn(
                data: *mut ::std::os::raw::c_void,
                idx: ::std::os::raw::c_int,
            ) -> ImPlotPoint,
        >,
        data1: *mut ::std::os::raw::c_void,
        getter2: ::std::option::Option<
            unsafe extern "C" fn(
                data: *mut ::std::os::raw::c_void,
                idx: ::std::os::raw::c_int,
            ) -> ImPlotPoint,
        >,
        data2: *mut ::std::os::raw::c_void,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotBarsFloatPtrIntFloat(
        label_id: *const ::std::os::raw::c_char,
        values: *const f32,
        count: ::std::os::raw::c_int,
        width: f32,
        shift: f32,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotBarsdoublePtrIntdouble(
        label_id: *const ::std::os::raw::c_char,
        values: *const f64,
        count: ::std::os::raw::c_int,
        width: f64,
        shift: f64,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotBarsFloatPtrFloatPtr(
        label_id: *const ::std::os::raw::c_char,
        xs: *const f32,
        ys: *const f32,
        count: ::std::os::raw::c_int,
        width: f32,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotBarsdoublePtrdoublePtr(
        label_id: *const ::std::os::raw::c_char,
        xs: *const f64,
        ys: *const f64,
        count: ::std::os::raw::c_int,
        width: f64,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotBarsFnPlotPoIntPtr(
        label_id: *const ::std::os::raw::c_char,
        getter: ::std::option::Option<
            unsafe extern "C" fn(
                data: *mut ::std::os::raw::c_void,
                idx: ::std::os::raw::c_int,
            ) -> ImPlotPoint,
        >,
        data: *mut ::std::os::raw::c_void,
        count: ::std::os::raw::c_int,
        width: f64,
        offset: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotBarsHFloatPtrIntFloat(
        label_id: *const ::std::os::raw::c_char,
        values: *const f32,
        count: ::std::os::raw::c_int,
        height: f32,
        shift: f32,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotBarsHdoublePtrIntdouble(
        label_id: *const ::std::os::raw::c_char,
        values: *const f64,
        count: ::std::os::raw::c_int,
        height: f64,
        shift: f64,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotBarsHFloatPtrFloatPtr(
        label_id: *const ::std::os::raw::c_char,
        xs: *const f32,
        ys: *const f32,
        count: ::std::os::raw::c_int,
        height: f32,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotBarsHdoublePtrdoublePtr(
        label_id: *const ::std::os::raw::c_char,
        xs: *const f64,
        ys: *const f64,
        count: ::std::os::raw::c_int,
        height: f64,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotBarsHFnPlotPoIntPtr(
        label_id: *const ::std::os::raw::c_char,
        getter: ::std::option::Option<
            unsafe extern "C" fn(
                data: *mut ::std::os::raw::c_void,
                idx: ::std::os::raw::c_int,
            ) -> ImPlotPoint,
        >,
        data: *mut ::std::os::raw::c_void,
        count: ::std::os::raw::c_int,
        height: f64,
        offset: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotErrorBarsFloatPtrFloatPtrFloatPtrInt(
        label_id: *const ::std::os::raw::c_char,
        xs: *const f32,
        ys: *const f32,
        err: *const f32,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotErrorBarsdoublePtrdoublePtrdoublePtrInt(
        label_id: *const ::std::os::raw::c_char,
        xs: *const f64,
        ys: *const f64,
        err: *const f64,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotErrorBarsFloatPtrFloatPtrFloatPtrFloatPtr(
        label_id: *const ::std::os::raw::c_char,
        xs: *const f32,
        ys: *const f32,
        neg: *const f32,
        pos: *const f32,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotErrorBarsdoublePtrdoublePtrdoublePtrdoublePtr(
        label_id: *const ::std::os::raw::c_char,
        xs: *const f64,
        ys: *const f64,
        neg: *const f64,
        pos: *const f64,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotErrorBarsHFloatPtrFloatPtrFloatPtrInt(
        label_id: *const ::std::os::raw::c_char,
        xs: *const f32,
        ys: *const f32,
        err: *const f32,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotErrorBarsHdoublePtrdoublePtrdoublePtrInt(
        label_id: *const ::std::os::raw::c_char,
        xs: *const f64,
        ys: *const f64,
        err: *const f64,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotErrorBarsHFloatPtrFloatPtrFloatPtrFloatPtr(
        label_id: *const ::std::os::raw::c_char,
        xs: *const f32,
        ys: *const f32,
        neg: *const f32,
        pos: *const f32,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotErrorBarsHdoublePtrdoublePtrdoublePtrdoublePtr(
        label_id: *const ::std::os::raw::c_char,
        xs: *const f64,
        ys: *const f64,
        neg: *const f64,
        pos: *const f64,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotStemsFloatPtrIntFloat(
        label_id: *const ::std::os::raw::c_char,
        values: *const f32,
        count: ::std::os::raw::c_int,
        y_ref: f32,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotStemsdoublePtrIntdouble(
        label_id: *const ::std::os::raw::c_char,
        values: *const f64,
        count: ::std::os::raw::c_int,
        y_ref: f64,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotStemsFloatPtrFloatPtr(
        label_id: *const ::std::os::raw::c_char,
        xs: *const f32,
        ys: *const f32,
        count: ::std::os::raw::c_int,
        y_ref: f32,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotStemsdoublePtrdoublePtr(
        label_id: *const ::std::os::raw::c_char,
        xs: *const f64,
        ys: *const f64,
        count: ::std::os::raw::c_int,
        y_ref: f64,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotPieChartFloatPtr(
        label_ids: *mut *const ::std::os::raw::c_char,
        values: *const f32,
        count: ::std::os::raw::c_int,
        x: f32,
        y: f32,
        radius: f32,
        normalize: bool,
        label_fmt: *const ::std::os::raw::c_char,
        angle0: f32,
    );
}
extern "C" {
    pub fn ImPlot_PlotPieChartdoublePtr(
        label_ids: *mut *const ::std::os::raw::c_char,
        values: *const f64,
        count: ::std::os::raw::c_int,
        x: f64,
        y: f64,
        radius: f64,
        normalize: bool,
        label_fmt: *const ::std::os::raw::c_char,
        angle0: f64,
    );
}
extern "C" {
    pub fn ImPlot_PlotHeatmapFloatPtr(
        label_id: *const ::std::os::raw::c_char,
        values: *const f32,
        rows: ::std::os::raw::c_int,
        cols: ::std::os::raw::c_int,
        scale_min: f32,
        scale_max: f32,
        label_fmt: *const ::std::os::raw::c_char,
        bounds_min: ImPlotPoint,
        bounds_max: ImPlotPoint,
    );
}
extern "C" {
    pub fn ImPlot_PlotHeatmapdoublePtr(
        label_id: *const ::std::os::raw::c_char,
        values: *const f64,
        rows: ::std::os::raw::c_int,
        cols: ::std::os::raw::c_int,
        scale_min: f64,
        scale_max: f64,
        label_fmt: *const ::std::os::raw::c_char,
        bounds_min: ImPlotPoint,
        bounds_max: ImPlotPoint,
    );
}
extern "C" {
    pub fn ImPlot_PlotDigitalFloatPtr(
        label_id: *const ::std::os::raw::c_char,
        xs: *const f32,
        ys: *const f32,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotDigitaldoublePtr(
        label_id: *const ::std::os::raw::c_char,
        xs: *const f64,
        ys: *const f64,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
        stride: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotDigitalFnPlotPoIntPtr(
        label_id: *const ::std::os::raw::c_char,
        getter: ::std::option::Option<
            unsafe extern "C" fn(
                data: *mut ::std::os::raw::c_void,
                idx: ::std::os::raw::c_int,
            ) -> ImPlotPoint,
        >,
        data: *mut ::std::os::raw::c_void,
        count: ::std::os::raw::c_int,
        offset: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotTextFloat(
        text: *const ::std::os::raw::c_char,
        x: f32,
        y: f32,
        vertical: bool,
        pixel_offset: ImVec2,
    );
}
extern "C" {
    pub fn ImPlot_PlotTextdouble(
        text: *const ::std::os::raw::c_char,
        x: f64,
        y: f64,
        vertical: bool,
        pixel_offset: ImVec2,
    );
}
extern "C" {
    pub fn ImPlot_SetNextPlotLimits(xmin: f64, xmax: f64, ymin: f64, ymax: f64, cond: ImGuiCond);
}
extern "C" {
    pub fn ImPlot_SetNextPlotLimitsX(xmin: f64, xmax: f64, cond: ImGuiCond);
}
extern "C" {
    pub fn ImPlot_SetNextPlotLimitsY(
        ymin: f64,
        ymax: f64,
        cond: ImGuiCond,
        y_axis: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_LinkNextPlotLimits(
        xmin: *mut f64,
        xmax: *mut f64,
        ymin: *mut f64,
        ymax: *mut f64,
        ymin2: *mut f64,
        ymax2: *mut f64,
        ymin3: *mut f64,
        ymax3: *mut f64,
    );
}
extern "C" {
    pub fn ImPlot_FitNextPlotAxes(x: bool, y: bool, y2: bool, y3: bool);
}
extern "C" {
    pub fn ImPlot_SetNextPlotTicksXdoublePtr(
        values: *const f64,
        n_ticks: ::std::os::raw::c_int,
        labels: *mut *const ::std::os::raw::c_char,
        show_default: bool,
    );
}
extern "C" {
    pub fn ImPlot_SetNextPlotTicksXdouble(
        x_min: f64,
        x_max: f64,
        n_ticks: ::std::os::raw::c_int,
        labels: *mut *const ::std::os::raw::c_char,
        show_default: bool,
    );
}
extern "C" {
    pub fn ImPlot_SetNextPlotTicksYdoublePtr(
        values: *const f64,
        n_ticks: ::std::os::raw::c_int,
        labels: *mut *const ::std::os::raw::c_char,
        show_default: bool,
        y_axis: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_SetNextPlotTicksYdouble(
        y_min: f64,
        y_max: f64,
        n_ticks: ::std::os::raw::c_int,
        labels: *mut *const ::std::os::raw::c_char,
        show_default: bool,
        y_axis: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_SetPlotYAxis(y_axis: ::std::os::raw::c_int);
}
extern "C" {
    pub fn ImPlot_PixelsToPlotVec2(
        pOut: *mut ImPlotPoint,
        pix: ImVec2,
        y_axis: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PixelsToPlotFloat(
        pOut: *mut ImPlotPoint,
        x: f32,
        y: f32,
        y_axis: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotToPixelsPlotPoInt(
        pOut: *mut ImVec2,
        plt: ImPlotPoint,
        y_axis: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_PlotToPixelsdouble(
        pOut: *mut ImVec2,
        x: f64,
        y: f64,
        y_axis: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn ImPlot_GetPlotPos(pOut: *mut ImVec2);
}
extern "C" {
    pub fn ImPlot_GetPlotSize(pOut: *mut ImVec2);
}
extern "C" {
    pub fn ImPlot_IsPlotHovered() -> bool;
}
extern "C" {
    pub fn ImPlot_IsPlotXAxisHovered() -> bool;
}
extern "C" {
    pub fn ImPlot_IsPlotYAxisHovered(y_axis: ::std::os::raw::c_int) -> bool;
}
extern "C" {
    pub fn ImPlot_GetPlotMousePos(pOut: *mut ImPlotPoint, y_axis: ::std::os::raw::c_int);
}
extern "C" {
    pub fn ImPlot_GetPlotLimits(pOut: *mut ImPlotLimits, y_axis: ::std::os::raw::c_int);
}
extern "C" {
    pub fn ImPlot_IsPlotQueried() -> bool;
}
extern "C" {
    pub fn ImPlot_GetPlotQuery(pOut: *mut ImPlotLimits, y_axis: ::std::os::raw::c_int);
}
extern "C" {
    pub fn ImPlot_GetStyle() -> *mut ImPlotStyle;
}
extern "C" {
    pub fn ImPlot_StyleColorsAuto(dst: *mut ImPlotStyle);
}
extern "C" {
    pub fn ImPlot_StyleColorsClassic(dst: *mut ImPlotStyle);
}
extern "C" {
    pub fn ImPlot_StyleColorsDark(dst: *mut ImPlotStyle);
}
extern "C" {
    pub fn ImPlot_StyleColorsLight(dst: *mut ImPlotStyle);
}
extern "C" {
    pub fn ImPlot_PushStyleColorU32(idx: ImPlotCol, col: ImU32);
}
extern "C" {
    pub fn ImPlot_PushStyleColorVec4(idx: ImPlotCol, col: ImVec4);
}
extern "C" {
    pub fn ImPlot_PopStyleColor(count: ::std::os::raw::c_int);
}
extern "C" {
    pub fn ImPlot_PushStyleVarFloat(idx: ImPlotStyleVar, val: f32);
}
extern "C" {
    pub fn ImPlot_PushStyleVarInt(idx: ImPlotStyleVar, val: ::std::os::raw::c_int);
}
extern "C" {
    pub fn ImPlot_PushStyleVarVec2(idx: ImPlotStyleVar, val: ImVec2);
}
extern "C" {
    pub fn ImPlot_PopStyleVar(count: ::std::os::raw::c_int);
}
extern "C" {
    pub fn ImPlot_SetNextLineStyle(col: ImVec4, weight: f32);
}
extern "C" {
    pub fn ImPlot_SetNextFillStyle(col: ImVec4, alpha_mod: f32);
}
extern "C" {
    pub fn ImPlot_SetNextMarkerStyle(
        marker: ImPlotMarker,
        size: f32,
        fill: ImVec4,
        weight: f32,
        outline: ImVec4,
    );
}
extern "C" {
    pub fn ImPlot_SetNextErrorBarStyle(col: ImVec4, size: f32, weight: f32);
}
extern "C" {
    pub fn ImPlot_GetStyleColorName(color: ImPlotCol) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn ImPlot_GetMarkerName(marker: ImPlotMarker) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn ImPlot_PushColormapPlotColormap(colormap: ImPlotColormap);
}
extern "C" {
    pub fn ImPlot_PushColormapVec4Ptr(colormap: *const ImVec4, size: ::std::os::raw::c_int);
}
extern "C" {
    pub fn ImPlot_PopColormap(count: ::std::os::raw::c_int);
}
extern "C" {
    pub fn ImPlot_SetColormapVec4Ptr(colormap: *const ImVec4, size: ::std::os::raw::c_int);
}
extern "C" {
    pub fn ImPlot_SetColormapPlotColormap(colormap: ImPlotColormap, samples: ::std::os::raw::c_int);
}
extern "C" {
    pub fn ImPlot_GetColormapSize() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn ImPlot_GetColormapColor(pOut: *mut ImVec4, index: ::std::os::raw::c_int);
}
extern "C" {
    pub fn ImPlot_LerpColormap(pOut: *mut ImVec4, t: f32);
}
extern "C" {
    pub fn ImPlot_NextColormapColor(pOut: *mut ImVec4);
}
extern "C" {
    pub fn ImPlot_ShowColormapScale(scale_min: f64, scale_max: f64, height: f32);
}
extern "C" {
    pub fn ImPlot_GetColormapName(colormap: ImPlotColormap) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn ImPlot_IsLegendEntryHovered(label_id: *const ::std::os::raw::c_char) -> bool;
}
extern "C" {
    pub fn ImPlot_BeginLegendDragDropSource(
        label_id: *const ::std::os::raw::c_char,
        flags: ImGuiDragDropFlags,
    ) -> bool;
}
extern "C" {
    pub fn ImPlot_EndLegendDragDropSource();
}
extern "C" {
    pub fn ImPlot_BeginLegendPopup(
        label_id: *const ::std::os::raw::c_char,
        mouse_button: ImGuiMouseButton,
    ) -> bool;
}
extern "C" {
    pub fn ImPlot_EndLegendPopup();
}
extern "C" {
    pub fn ImPlot_GetInputMap() -> *mut ImPlotInputMap;
}
extern "C" {
    pub fn ImPlot_GetPlotDrawList() -> *mut ImDrawList;
}
extern "C" {
    pub fn ImPlot_PushPlotClipRect();
}
extern "C" {
    pub fn ImPlot_PopPlotClipRect();
}
extern "C" {
    pub fn ImPlot_ShowStyleSelector(label: *const ::std::os::raw::c_char) -> bool;
}
extern "C" {
    pub fn ImPlot_ShowStyleEditor(ref_: *mut ImPlotStyle);
}
extern "C" {
    pub fn ImPlot_ShowUserGuide();
}
extern "C" {
    pub fn ImPlot_ShowDemoWindow(p_open: *mut bool);
}