mhgu-forge-sys 1.1.3

/* automatically generated by rust-bindgen 0.72.1 */

#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage> {
    storage: Storage,
}
impl<Storage> __BindgenBitfieldUnit<Storage> {
    #[inline]
    pub const fn new(storage: Storage) -> Self {
        Self { storage }
    }
}
impl<Storage> __BindgenBitfieldUnit<Storage>
where
    Storage: AsRef<[u8]> + AsMut<[u8]>,
{
    #[inline]
    fn extract_bit(byte: u8, index: usize) -> bool {
        let bit_index = if cfg!(target_endian = "big") {
            7 - (index % 8)
        } else {
            index % 8
        };
        let mask = 1 << bit_index;
        byte & mask == mask
    }
    #[inline]
    pub fn get_bit(&self, index: usize) -> bool {
        debug_assert!(index / 8 < self.storage.as_ref().len());
        let byte_index = index / 8;
        let byte = self.storage.as_ref()[byte_index];
        Self::extract_bit(byte, index)
    }
    #[inline]
    pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
        debug_assert!(index / 8 < core::mem::size_of::<Storage>());
        let byte_index = index / 8;
        let byte = unsafe { *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize) };
        Self::extract_bit(byte, index)
    }
    #[inline]
    fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
        let bit_index = if cfg!(target_endian = "big") {
            7 - (index % 8)
        } else {
            index % 8
        };
        let mask = 1 << bit_index;
        if val { byte | mask } else { byte & !mask }
    }
    #[inline]
    pub fn set_bit(&mut self, index: usize, val: bool) {
        debug_assert!(index / 8 < self.storage.as_ref().len());
        let byte_index = index / 8;
        let byte = &mut self.storage.as_mut()[byte_index];
        *byte = Self::change_bit(*byte, index, val);
    }
    #[inline]
    pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
        debug_assert!(index / 8 < core::mem::size_of::<Storage>());
        let byte_index = index / 8;
        let byte = unsafe { (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize) };
        unsafe { *byte = Self::change_bit(*byte, index, val) };
    }
    #[inline]
    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
        let mut val = 0;
        for i in 0..(bit_width as usize) {
            if self.get_bit(i + bit_offset) {
                let index = if cfg!(target_endian = "big") {
                    bit_width as usize - 1 - i
                } else {
                    i
                };
                val |= 1 << index;
            }
        }
        val
    }
    #[inline]
    pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
        let mut val = 0;
        for i in 0..(bit_width as usize) {
            if unsafe { Self::raw_get_bit(this, i + bit_offset) } {
                let index = if cfg!(target_endian = "big") {
                    bit_width as usize - 1 - i
                } else {
                    i
                };
                val |= 1 << index;
            }
        }
        val
    }
    #[inline]
    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
        for i in 0..(bit_width as usize) {
            let mask = 1 << i;
            let val_bit_is_set = val & mask == mask;
            let index = if cfg!(target_endian = "big") {
                bit_width as usize - 1 - i
            } else {
                i
            };
            self.set_bit(index + bit_offset, val_bit_is_set);
        }
    }
    #[inline]
    pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
        for i in 0..(bit_width as usize) {
            let mask = 1 << i;
            let val_bit_is_set = val & mask == mask;
            let index = if cfg!(target_endian = "big") {
                bit_width as usize - 1 - i
            } else {
                i
            };
            unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) };
        }
    }
}
pub const IM_UNICODE_CODEPOINT_MAX: u32 = 65535;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ForgeImGuiFile {
    _unused: [u8; 0],
}
pub type FILE = _ForgeImGuiFile;
pub type va_list = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiInputTextDeactivateData {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiTableColumnsSettings {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct STB_TexteditState {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct stbrp_node {
    _unused: [u8; 0],
}
pub type ImGuiID = ::core::ffi::c_uint;
pub type ImS8 = ::core::ffi::c_schar;
pub type ImU8 = ::core::ffi::c_uchar;
pub type ImS16 = ::core::ffi::c_short;
pub type ImU16 = ::core::ffi::c_ushort;
pub type ImS32 = ::core::ffi::c_int;
pub type ImU32 = ::core::ffi::c_uint;
pub type ImS64 = ::core::ffi::c_longlong;
pub type ImU64 = ::core::ffi::c_ulonglong;
pub type ImGuiKeyChord = ::core::ffi::c_int;
pub type ImWchar32 = ::core::ffi::c_uint;
pub type ImWchar16 = ::core::ffi::c_ushort;
pub type ImWchar = ImWchar16;
pub type ImGuiSelectionUserData = ImS64;
pub type ImGuiInputTextCallback =
    ::core::option::Option<unsafe extern "C" fn(data: *mut ImGuiInputTextCallbackData) -> ::core::ffi::c_int>;
pub type ImGuiSizeCallback = ::core::option::Option<unsafe extern "C" fn(data: *mut ImGuiSizeCallbackData)>;
pub type ImGuiMemAllocFunc =
    ::core::option::Option<unsafe extern "C" fn(sz: usize, user_data: *mut ::core::ffi::c_void) -> *mut ::core::ffi::c_void>;
pub type ImGuiMemFreeFunc =
    ::core::option::Option<unsafe extern "C" fn(ptr: *mut ::core::ffi::c_void, user_data: *mut ::core::ffi::c_void)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVec2_c {
    pub x: f32,
    pub y: f32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVec4_c {
    pub x: f32,
    pub y: f32,
    pub z: f32,
    pub w: f32,
}
pub type ImTextureID = ImU64;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImTextureRef_c {
    pub _TexData: *mut ImTextureData,
    pub _TexID: ImTextureID,
}
impl ImGuiWindowFlags {
    pub const None: ImGuiWindowFlags = ImGuiWindowFlags(0);
    pub const NoTitleBar: ImGuiWindowFlags = ImGuiWindowFlags(1);
    pub const NoResize: ImGuiWindowFlags = ImGuiWindowFlags(2);
    pub const NoMove: ImGuiWindowFlags = ImGuiWindowFlags(4);
    pub const NoScrollbar: ImGuiWindowFlags = ImGuiWindowFlags(8);
    pub const NoScrollWithMouse: ImGuiWindowFlags = ImGuiWindowFlags(16);
    pub const NoCollapse: ImGuiWindowFlags = ImGuiWindowFlags(32);
    pub const AlwaysAutoResize: ImGuiWindowFlags = ImGuiWindowFlags(64);
    pub const NoBackground: ImGuiWindowFlags = ImGuiWindowFlags(128);
    pub const NoSavedSettings: ImGuiWindowFlags = ImGuiWindowFlags(256);
    pub const NoMouseInputs: ImGuiWindowFlags = ImGuiWindowFlags(512);
    pub const MenuBar: ImGuiWindowFlags = ImGuiWindowFlags(1024);
    pub const HorizontalScrollbar: ImGuiWindowFlags = ImGuiWindowFlags(2048);
    pub const NoFocusOnAppearing: ImGuiWindowFlags = ImGuiWindowFlags(4096);
    pub const NoBringToFrontOnFocus: ImGuiWindowFlags = ImGuiWindowFlags(8192);
    pub const AlwaysVerticalScrollbar: ImGuiWindowFlags = ImGuiWindowFlags(16384);
    pub const AlwaysHorizontalScrollbar: ImGuiWindowFlags = ImGuiWindowFlags(32768);
    pub const NoNavInputs: ImGuiWindowFlags = ImGuiWindowFlags(65536);
    pub const NoNavFocus: ImGuiWindowFlags = ImGuiWindowFlags(131072);
    pub const UnsavedDocument: ImGuiWindowFlags = ImGuiWindowFlags(262144);
    pub const NoNav: ImGuiWindowFlags = ImGuiWindowFlags(196608);
    pub const NoDecoration: ImGuiWindowFlags = ImGuiWindowFlags(43);
    pub const NoInputs: ImGuiWindowFlags = ImGuiWindowFlags(197120);
    pub const ChildWindow: ImGuiWindowFlags = ImGuiWindowFlags(16777216);
    pub const Tooltip: ImGuiWindowFlags = ImGuiWindowFlags(33554432);
    pub const Popup: ImGuiWindowFlags = ImGuiWindowFlags(67108864);
    pub const Modal: ImGuiWindowFlags = ImGuiWindowFlags(134217728);
    pub const ChildMenu: ImGuiWindowFlags = ImGuiWindowFlags(268435456);
}
impl ::core::ops::BitOr<ImGuiWindowFlags> for ImGuiWindowFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiWindowFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiWindowFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiWindowFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiWindowFlags> for ImGuiWindowFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiWindowFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiWindowFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiWindowFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiWindowFlags(pub ::core::ffi::c_uint);
impl ImGuiChildFlags {
    pub const None: ImGuiChildFlags = ImGuiChildFlags(0);
    pub const Borders: ImGuiChildFlags = ImGuiChildFlags(1);
    pub const AlwaysUseWindowPadding: ImGuiChildFlags = ImGuiChildFlags(2);
    pub const ResizeX: ImGuiChildFlags = ImGuiChildFlags(4);
    pub const ResizeY: ImGuiChildFlags = ImGuiChildFlags(8);
    pub const AutoResizeX: ImGuiChildFlags = ImGuiChildFlags(16);
    pub const AutoResizeY: ImGuiChildFlags = ImGuiChildFlags(32);
    pub const AlwaysAutoResize: ImGuiChildFlags = ImGuiChildFlags(64);
    pub const FrameStyle: ImGuiChildFlags = ImGuiChildFlags(128);
    pub const NavFlattened: ImGuiChildFlags = ImGuiChildFlags(256);
}
impl ::core::ops::BitOr<ImGuiChildFlags> for ImGuiChildFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiChildFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiChildFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiChildFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiChildFlags> for ImGuiChildFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiChildFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiChildFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiChildFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiChildFlags(pub ::core::ffi::c_uint);
impl ImGuiItemFlags {
    pub const None: ImGuiItemFlags = ImGuiItemFlags(0);
    pub const NoTabStop: ImGuiItemFlags = ImGuiItemFlags(1);
    pub const NoNav: ImGuiItemFlags = ImGuiItemFlags(2);
    pub const NoNavDefaultFocus: ImGuiItemFlags = ImGuiItemFlags(4);
    pub const ButtonRepeat: ImGuiItemFlags = ImGuiItemFlags(8);
    pub const AutoClosePopups: ImGuiItemFlags = ImGuiItemFlags(16);
    pub const AllowDuplicateId: ImGuiItemFlags = ImGuiItemFlags(32);
    pub const Disabled: ImGuiItemFlags = ImGuiItemFlags(64);
}
impl ::core::ops::BitOr<ImGuiItemFlags> for ImGuiItemFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiItemFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiItemFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiItemFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiItemFlags> for ImGuiItemFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiItemFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiItemFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiItemFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiItemFlags(pub ::core::ffi::c_uint);
impl ImGuiInputTextFlags {
    pub const None: ImGuiInputTextFlags = ImGuiInputTextFlags(0);
    pub const CharsDecimal: ImGuiInputTextFlags = ImGuiInputTextFlags(1);
    pub const CharsHexadecimal: ImGuiInputTextFlags = ImGuiInputTextFlags(2);
    pub const CharsScientific: ImGuiInputTextFlags = ImGuiInputTextFlags(4);
    pub const CharsUppercase: ImGuiInputTextFlags = ImGuiInputTextFlags(8);
    pub const CharsNoBlank: ImGuiInputTextFlags = ImGuiInputTextFlags(16);
    pub const AllowTabInput: ImGuiInputTextFlags = ImGuiInputTextFlags(32);
    pub const EnterReturnsTrue: ImGuiInputTextFlags = ImGuiInputTextFlags(64);
    pub const EscapeClearsAll: ImGuiInputTextFlags = ImGuiInputTextFlags(128);
    pub const CtrlEnterForNewLine: ImGuiInputTextFlags = ImGuiInputTextFlags(256);
    pub const ReadOnly: ImGuiInputTextFlags = ImGuiInputTextFlags(512);
    pub const Password: ImGuiInputTextFlags = ImGuiInputTextFlags(1024);
    pub const AlwaysOverwrite: ImGuiInputTextFlags = ImGuiInputTextFlags(2048);
    pub const AutoSelectAll: ImGuiInputTextFlags = ImGuiInputTextFlags(4096);
    pub const ParseEmptyRefVal: ImGuiInputTextFlags = ImGuiInputTextFlags(8192);
    pub const DisplayEmptyRefVal: ImGuiInputTextFlags = ImGuiInputTextFlags(16384);
    pub const NoHorizontalScroll: ImGuiInputTextFlags = ImGuiInputTextFlags(32768);
    pub const NoUndoRedo: ImGuiInputTextFlags = ImGuiInputTextFlags(65536);
    pub const ElideLeft: ImGuiInputTextFlags = ImGuiInputTextFlags(131072);
    pub const CallbackCompletion: ImGuiInputTextFlags = ImGuiInputTextFlags(262144);
    pub const CallbackHistory: ImGuiInputTextFlags = ImGuiInputTextFlags(524288);
    pub const CallbackAlways: ImGuiInputTextFlags = ImGuiInputTextFlags(1048576);
    pub const CallbackCharFilter: ImGuiInputTextFlags = ImGuiInputTextFlags(2097152);
    pub const CallbackResize: ImGuiInputTextFlags = ImGuiInputTextFlags(4194304);
    pub const CallbackEdit: ImGuiInputTextFlags = ImGuiInputTextFlags(8388608);
    pub const WordWrap: ImGuiInputTextFlags = ImGuiInputTextFlags(16777216);
}
impl ::core::ops::BitOr<ImGuiInputTextFlags> for ImGuiInputTextFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiInputTextFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiInputTextFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiInputTextFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiInputTextFlags> for ImGuiInputTextFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiInputTextFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiInputTextFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiInputTextFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiInputTextFlags(pub ::core::ffi::c_uint);
impl ImGuiTreeNodeFlags {
    pub const None: ImGuiTreeNodeFlags = ImGuiTreeNodeFlags(0);
    pub const Selected: ImGuiTreeNodeFlags = ImGuiTreeNodeFlags(1);
    pub const Framed: ImGuiTreeNodeFlags = ImGuiTreeNodeFlags(2);
    pub const AllowOverlap: ImGuiTreeNodeFlags = ImGuiTreeNodeFlags(4);
    pub const NoTreePushOnOpen: ImGuiTreeNodeFlags = ImGuiTreeNodeFlags(8);
    pub const NoAutoOpenOnLog: ImGuiTreeNodeFlags = ImGuiTreeNodeFlags(16);
    pub const DefaultOpen: ImGuiTreeNodeFlags = ImGuiTreeNodeFlags(32);
    pub const OpenOnDoubleClick: ImGuiTreeNodeFlags = ImGuiTreeNodeFlags(64);
    pub const OpenOnArrow: ImGuiTreeNodeFlags = ImGuiTreeNodeFlags(128);
    pub const Leaf: ImGuiTreeNodeFlags = ImGuiTreeNodeFlags(256);
    pub const Bullet: ImGuiTreeNodeFlags = ImGuiTreeNodeFlags(512);
    pub const FramePadding: ImGuiTreeNodeFlags = ImGuiTreeNodeFlags(1024);
    pub const SpanAvailWidth: ImGuiTreeNodeFlags = ImGuiTreeNodeFlags(2048);
    pub const SpanFullWidth: ImGuiTreeNodeFlags = ImGuiTreeNodeFlags(4096);
    pub const SpanLabelWidth: ImGuiTreeNodeFlags = ImGuiTreeNodeFlags(8192);
    pub const SpanAllColumns: ImGuiTreeNodeFlags = ImGuiTreeNodeFlags(16384);
    pub const LabelSpanAllColumns: ImGuiTreeNodeFlags = ImGuiTreeNodeFlags(32768);
    pub const NavLeftJumpsToParent: ImGuiTreeNodeFlags = ImGuiTreeNodeFlags(131072);
    pub const CollapsingHeader: ImGuiTreeNodeFlags = ImGuiTreeNodeFlags(26);
    pub const DrawLinesNone: ImGuiTreeNodeFlags = ImGuiTreeNodeFlags(262144);
    pub const DrawLinesFull: ImGuiTreeNodeFlags = ImGuiTreeNodeFlags(524288);
    pub const DrawLinesToNodes: ImGuiTreeNodeFlags = ImGuiTreeNodeFlags(1048576);
}
impl ::core::ops::BitOr<ImGuiTreeNodeFlags> for ImGuiTreeNodeFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiTreeNodeFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiTreeNodeFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiTreeNodeFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiTreeNodeFlags> for ImGuiTreeNodeFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiTreeNodeFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiTreeNodeFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiTreeNodeFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiTreeNodeFlags(pub ::core::ffi::c_uint);
impl ImGuiPopupFlags {
    pub const None: ImGuiPopupFlags = ImGuiPopupFlags(0);
    pub const MouseButtonLeft: ImGuiPopupFlags = ImGuiPopupFlags(4);
    pub const MouseButtonRight: ImGuiPopupFlags = ImGuiPopupFlags(8);
    pub const MouseButtonMiddle: ImGuiPopupFlags = ImGuiPopupFlags(12);
    pub const NoReopen: ImGuiPopupFlags = ImGuiPopupFlags(32);
    pub const NoOpenOverExistingPopup: ImGuiPopupFlags = ImGuiPopupFlags(128);
    pub const NoOpenOverItems: ImGuiPopupFlags = ImGuiPopupFlags(256);
    pub const AnyPopupId: ImGuiPopupFlags = ImGuiPopupFlags(1024);
    pub const AnyPopupLevel: ImGuiPopupFlags = ImGuiPopupFlags(2048);
    pub const AnyPopup: ImGuiPopupFlags = ImGuiPopupFlags(3072);
    pub const MouseButtonShift_: ImGuiPopupFlags = ImGuiPopupFlags(2);
    pub const MouseButtonMask_: ImGuiPopupFlags = ImGuiPopupFlags(12);
    pub const InvalidMask_: ImGuiPopupFlags = ImGuiPopupFlags(3);
}
impl ::core::ops::BitOr<ImGuiPopupFlags> for ImGuiPopupFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiPopupFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiPopupFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiPopupFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiPopupFlags> for ImGuiPopupFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiPopupFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiPopupFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiPopupFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiPopupFlags(pub ::core::ffi::c_uint);
impl ImGuiSelectableFlags {
    pub const None: ImGuiSelectableFlags = ImGuiSelectableFlags(0);
    pub const NoAutoClosePopups: ImGuiSelectableFlags = ImGuiSelectableFlags(1);
    pub const SpanAllColumns: ImGuiSelectableFlags = ImGuiSelectableFlags(2);
    pub const AllowDoubleClick: ImGuiSelectableFlags = ImGuiSelectableFlags(4);
    pub const Disabled: ImGuiSelectableFlags = ImGuiSelectableFlags(8);
    pub const AllowOverlap: ImGuiSelectableFlags = ImGuiSelectableFlags(16);
    pub const Highlight: ImGuiSelectableFlags = ImGuiSelectableFlags(32);
    pub const SelectOnNav: ImGuiSelectableFlags = ImGuiSelectableFlags(64);
}
impl ::core::ops::BitOr<ImGuiSelectableFlags> for ImGuiSelectableFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiSelectableFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiSelectableFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiSelectableFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiSelectableFlags> for ImGuiSelectableFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiSelectableFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiSelectableFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiSelectableFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiSelectableFlags(pub ::core::ffi::c_uint);
impl ImGuiComboFlags {
    pub const None: ImGuiComboFlags = ImGuiComboFlags(0);
    pub const PopupAlignLeft: ImGuiComboFlags = ImGuiComboFlags(1);
    pub const HeightSmall: ImGuiComboFlags = ImGuiComboFlags(2);
    pub const HeightRegular: ImGuiComboFlags = ImGuiComboFlags(4);
    pub const HeightLarge: ImGuiComboFlags = ImGuiComboFlags(8);
    pub const HeightLargest: ImGuiComboFlags = ImGuiComboFlags(16);
    pub const NoArrowButton: ImGuiComboFlags = ImGuiComboFlags(32);
    pub const NoPreview: ImGuiComboFlags = ImGuiComboFlags(64);
    pub const WidthFitPreview: ImGuiComboFlags = ImGuiComboFlags(128);
    pub const HeightMask_: ImGuiComboFlags = ImGuiComboFlags(30);
}
impl ::core::ops::BitOr<ImGuiComboFlags> for ImGuiComboFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiComboFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiComboFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiComboFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiComboFlags> for ImGuiComboFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiComboFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiComboFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiComboFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiComboFlags(pub ::core::ffi::c_uint);
impl ImGuiTabBarFlags {
    pub const None: ImGuiTabBarFlags = ImGuiTabBarFlags(0);
    pub const Reorderable: ImGuiTabBarFlags = ImGuiTabBarFlags(1);
    pub const AutoSelectNewTabs: ImGuiTabBarFlags = ImGuiTabBarFlags(2);
    pub const TabListPopupButton: ImGuiTabBarFlags = ImGuiTabBarFlags(4);
    pub const NoCloseWithMiddleMouseButton: ImGuiTabBarFlags = ImGuiTabBarFlags(8);
    pub const NoTabListScrollingButtons: ImGuiTabBarFlags = ImGuiTabBarFlags(16);
    pub const NoTooltip: ImGuiTabBarFlags = ImGuiTabBarFlags(32);
    pub const DrawSelectedOverline: ImGuiTabBarFlags = ImGuiTabBarFlags(64);
    pub const FittingPolicyMixed: ImGuiTabBarFlags = ImGuiTabBarFlags(128);
    pub const FittingPolicyShrink: ImGuiTabBarFlags = ImGuiTabBarFlags(256);
    pub const FittingPolicyScroll: ImGuiTabBarFlags = ImGuiTabBarFlags(512);
    pub const FittingPolicyMask_: ImGuiTabBarFlags = ImGuiTabBarFlags(896);
    pub const FittingPolicyDefault_: ImGuiTabBarFlags = ImGuiTabBarFlags(128);
}
impl ::core::ops::BitOr<ImGuiTabBarFlags> for ImGuiTabBarFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiTabBarFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiTabBarFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiTabBarFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiTabBarFlags> for ImGuiTabBarFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiTabBarFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiTabBarFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiTabBarFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiTabBarFlags(pub ::core::ffi::c_uint);
impl ImGuiTabItemFlags {
    pub const None: ImGuiTabItemFlags = ImGuiTabItemFlags(0);
    pub const UnsavedDocument: ImGuiTabItemFlags = ImGuiTabItemFlags(1);
    pub const SetSelected: ImGuiTabItemFlags = ImGuiTabItemFlags(2);
    pub const NoCloseWithMiddleMouseButton: ImGuiTabItemFlags = ImGuiTabItemFlags(4);
    pub const NoPushId: ImGuiTabItemFlags = ImGuiTabItemFlags(8);
    pub const NoTooltip: ImGuiTabItemFlags = ImGuiTabItemFlags(16);
    pub const NoReorder: ImGuiTabItemFlags = ImGuiTabItemFlags(32);
    pub const Leading: ImGuiTabItemFlags = ImGuiTabItemFlags(64);
    pub const Trailing: ImGuiTabItemFlags = ImGuiTabItemFlags(128);
    pub const NoAssumedClosure: ImGuiTabItemFlags = ImGuiTabItemFlags(256);
}
impl ::core::ops::BitOr<ImGuiTabItemFlags> for ImGuiTabItemFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiTabItemFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiTabItemFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiTabItemFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiTabItemFlags> for ImGuiTabItemFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiTabItemFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiTabItemFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiTabItemFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiTabItemFlags(pub ::core::ffi::c_uint);
impl ImGuiFocusedFlags {
    pub const None: ImGuiFocusedFlags = ImGuiFocusedFlags(0);
    pub const ChildWindows: ImGuiFocusedFlags = ImGuiFocusedFlags(1);
    pub const RootWindow: ImGuiFocusedFlags = ImGuiFocusedFlags(2);
    pub const AnyWindow: ImGuiFocusedFlags = ImGuiFocusedFlags(4);
    pub const NoPopupHierarchy: ImGuiFocusedFlags = ImGuiFocusedFlags(8);
    pub const RootAndChildWindows: ImGuiFocusedFlags = ImGuiFocusedFlags(3);
}
impl ::core::ops::BitOr<ImGuiFocusedFlags> for ImGuiFocusedFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiFocusedFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiFocusedFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiFocusedFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiFocusedFlags> for ImGuiFocusedFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiFocusedFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiFocusedFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiFocusedFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiFocusedFlags(pub ::core::ffi::c_uint);
impl ImGuiHoveredFlags {
    pub const None: ImGuiHoveredFlags = ImGuiHoveredFlags(0);
    pub const ChildWindows: ImGuiHoveredFlags = ImGuiHoveredFlags(1);
    pub const RootWindow: ImGuiHoveredFlags = ImGuiHoveredFlags(2);
    pub const AnyWindow: ImGuiHoveredFlags = ImGuiHoveredFlags(4);
    pub const NoPopupHierarchy: ImGuiHoveredFlags = ImGuiHoveredFlags(8);
    pub const AllowWhenBlockedByPopup: ImGuiHoveredFlags = ImGuiHoveredFlags(32);
    pub const AllowWhenBlockedByActiveItem: ImGuiHoveredFlags = ImGuiHoveredFlags(128);
    pub const AllowWhenOverlappedByItem: ImGuiHoveredFlags = ImGuiHoveredFlags(256);
    pub const AllowWhenOverlappedByWindow: ImGuiHoveredFlags = ImGuiHoveredFlags(512);
    pub const AllowWhenDisabled: ImGuiHoveredFlags = ImGuiHoveredFlags(1024);
    pub const NoNavOverride: ImGuiHoveredFlags = ImGuiHoveredFlags(2048);
    pub const AllowWhenOverlapped: ImGuiHoveredFlags = ImGuiHoveredFlags(768);
    pub const RectOnly: ImGuiHoveredFlags = ImGuiHoveredFlags(928);
    pub const RootAndChildWindows: ImGuiHoveredFlags = ImGuiHoveredFlags(3);
    pub const ForTooltip: ImGuiHoveredFlags = ImGuiHoveredFlags(4096);
    pub const Stationary: ImGuiHoveredFlags = ImGuiHoveredFlags(8192);
    pub const DelayNone: ImGuiHoveredFlags = ImGuiHoveredFlags(16384);
    pub const DelayShort: ImGuiHoveredFlags = ImGuiHoveredFlags(32768);
    pub const DelayNormal: ImGuiHoveredFlags = ImGuiHoveredFlags(65536);
    pub const NoSharedDelay: ImGuiHoveredFlags = ImGuiHoveredFlags(131072);
}
impl ::core::ops::BitOr<ImGuiHoveredFlags> for ImGuiHoveredFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiHoveredFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiHoveredFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiHoveredFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiHoveredFlags> for ImGuiHoveredFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiHoveredFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiHoveredFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiHoveredFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiHoveredFlags(pub ::core::ffi::c_uint);
impl ImGuiDragDropFlags {
    pub const None: ImGuiDragDropFlags = ImGuiDragDropFlags(0);
    pub const SourceNoPreviewTooltip: ImGuiDragDropFlags = ImGuiDragDropFlags(1);
    pub const SourceNoDisableHover: ImGuiDragDropFlags = ImGuiDragDropFlags(2);
    pub const SourceNoHoldToOpenOthers: ImGuiDragDropFlags = ImGuiDragDropFlags(4);
    pub const SourceAllowNullID: ImGuiDragDropFlags = ImGuiDragDropFlags(8);
    pub const SourceExtern: ImGuiDragDropFlags = ImGuiDragDropFlags(16);
    pub const PayloadAutoExpire: ImGuiDragDropFlags = ImGuiDragDropFlags(32);
    pub const PayloadNoCrossContext: ImGuiDragDropFlags = ImGuiDragDropFlags(64);
    pub const PayloadNoCrossProcess: ImGuiDragDropFlags = ImGuiDragDropFlags(128);
    pub const AcceptBeforeDelivery: ImGuiDragDropFlags = ImGuiDragDropFlags(1024);
    pub const AcceptNoDrawDefaultRect: ImGuiDragDropFlags = ImGuiDragDropFlags(2048);
    pub const AcceptNoPreviewTooltip: ImGuiDragDropFlags = ImGuiDragDropFlags(4096);
    pub const AcceptDrawAsHovered: ImGuiDragDropFlags = ImGuiDragDropFlags(8192);
    pub const AcceptPeekOnly: ImGuiDragDropFlags = ImGuiDragDropFlags(3072);
}
impl ::core::ops::BitOr<ImGuiDragDropFlags> for ImGuiDragDropFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiDragDropFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiDragDropFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiDragDropFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiDragDropFlags> for ImGuiDragDropFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiDragDropFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiDragDropFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiDragDropFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiDragDropFlags(pub ::core::ffi::c_uint);
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ImGuiDataType {
    S8 = 0,
    U8 = 1,
    S16 = 2,
    U16 = 3,
    S32 = 4,
    U32 = 5,
    S64 = 6,
    U64 = 7,
    Float = 8,
    Double = 9,
    Bool = 10,
    String = 11,
    COUNT = 12,
}
#[repr(i32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ImGuiDir {
    None = -1,
    Left = 0,
    Right = 1,
    Up = 2,
    Down = 3,
    COUNT = 4,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ImGuiSortDirection {
    None = 0,
    Ascending = 1,
    Descending = 2,
}
impl ImGuiKey {
    pub const Tab: ImGuiKey = ImGuiKey::NamedKey_BEGIN;
}
impl ImGuiKey {
    pub const ImGuiMod_None: ImGuiKey = ImGuiKey::None;
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ImGuiKey {
    None = 0,
    NamedKey_BEGIN = 512,
    LeftArrow = 513,
    RightArrow = 514,
    UpArrow = 515,
    DownArrow = 516,
    PageUp = 517,
    PageDown = 518,
    Home = 519,
    End = 520,
    Insert = 521,
    Delete = 522,
    Backspace = 523,
    Space = 524,
    Enter = 525,
    Escape = 526,
    LeftCtrl = 527,
    LeftShift = 528,
    LeftAlt = 529,
    LeftSuper = 530,
    RightCtrl = 531,
    RightShift = 532,
    RightAlt = 533,
    RightSuper = 534,
    Menu = 535,
    _0 = 536,
    _1 = 537,
    _2 = 538,
    _3 = 539,
    _4 = 540,
    _5 = 541,
    _6 = 542,
    _7 = 543,
    _8 = 544,
    _9 = 545,
    A = 546,
    B = 547,
    C = 548,
    D = 549,
    E = 550,
    F = 551,
    G = 552,
    H = 553,
    I = 554,
    J = 555,
    K = 556,
    L = 557,
    M = 558,
    N = 559,
    O = 560,
    P = 561,
    Q = 562,
    R = 563,
    S = 564,
    T = 565,
    U = 566,
    V = 567,
    W = 568,
    X = 569,
    Y = 570,
    Z = 571,
    F1 = 572,
    F2 = 573,
    F3 = 574,
    F4 = 575,
    F5 = 576,
    F6 = 577,
    F7 = 578,
    F8 = 579,
    F9 = 580,
    F10 = 581,
    F11 = 582,
    F12 = 583,
    F13 = 584,
    F14 = 585,
    F15 = 586,
    F16 = 587,
    F17 = 588,
    F18 = 589,
    F19 = 590,
    F20 = 591,
    F21 = 592,
    F22 = 593,
    F23 = 594,
    F24 = 595,
    Apostrophe = 596,
    Comma = 597,
    Minus = 598,
    Period = 599,
    Slash = 600,
    Semicolon = 601,
    Equal = 602,
    LeftBracket = 603,
    Backslash = 604,
    RightBracket = 605,
    GraveAccent = 606,
    CapsLock = 607,
    ScrollLock = 608,
    NumLock = 609,
    PrintScreen = 610,
    Pause = 611,
    Keypad0 = 612,
    Keypad1 = 613,
    Keypad2 = 614,
    Keypad3 = 615,
    Keypad4 = 616,
    Keypad5 = 617,
    Keypad6 = 618,
    Keypad7 = 619,
    Keypad8 = 620,
    Keypad9 = 621,
    KeypadDecimal = 622,
    KeypadDivide = 623,
    KeypadMultiply = 624,
    KeypadSubtract = 625,
    KeypadAdd = 626,
    KeypadEnter = 627,
    KeypadEqual = 628,
    AppBack = 629,
    AppForward = 630,
    Oem102 = 631,
    GamepadStart = 632,
    GamepadBack = 633,
    GamepadFaceLeft = 634,
    GamepadFaceRight = 635,
    GamepadFaceUp = 636,
    GamepadFaceDown = 637,
    GamepadDpadLeft = 638,
    GamepadDpadRight = 639,
    GamepadDpadUp = 640,
    GamepadDpadDown = 641,
    GamepadL1 = 642,
    GamepadR1 = 643,
    GamepadL2 = 644,
    GamepadR2 = 645,
    GamepadL3 = 646,
    GamepadR3 = 647,
    GamepadLStickLeft = 648,
    GamepadLStickRight = 649,
    GamepadLStickUp = 650,
    GamepadLStickDown = 651,
    GamepadRStickLeft = 652,
    GamepadRStickRight = 653,
    GamepadRStickUp = 654,
    GamepadRStickDown = 655,
    MouseLeft = 656,
    MouseRight = 657,
    MouseMiddle = 658,
    MouseX1 = 659,
    MouseX2 = 660,
    MouseWheelX = 661,
    MouseWheelY = 662,
    ReservedForModCtrl = 663,
    ReservedForModShift = 664,
    ReservedForModAlt = 665,
    ReservedForModSuper = 666,
    NamedKey_END = 667,
    NamedKey_COUNT = 155,
    ImGuiMod_Ctrl = 4096,
    ImGuiMod_Shift = 8192,
    ImGuiMod_Alt = 16384,
    ImGuiMod_Super = 32768,
    ImGuiMod_Mask_ = 61440,
}
impl ImGuiInputFlags {
    pub const None: ImGuiInputFlags = ImGuiInputFlags(0);
    pub const Repeat: ImGuiInputFlags = ImGuiInputFlags(1);
    pub const RouteActive: ImGuiInputFlags = ImGuiInputFlags(1024);
    pub const RouteFocused: ImGuiInputFlags = ImGuiInputFlags(2048);
    pub const RouteGlobal: ImGuiInputFlags = ImGuiInputFlags(4096);
    pub const RouteAlways: ImGuiInputFlags = ImGuiInputFlags(8192);
    pub const RouteOverFocused: ImGuiInputFlags = ImGuiInputFlags(16384);
    pub const RouteOverActive: ImGuiInputFlags = ImGuiInputFlags(32768);
    pub const RouteUnlessBgFocused: ImGuiInputFlags = ImGuiInputFlags(65536);
    pub const RouteFromRootWindow: ImGuiInputFlags = ImGuiInputFlags(131072);
    pub const Tooltip: ImGuiInputFlags = ImGuiInputFlags(262144);
}
impl ::core::ops::BitOr<ImGuiInputFlags> for ImGuiInputFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiInputFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiInputFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiInputFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiInputFlags> for ImGuiInputFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiInputFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiInputFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiInputFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiInputFlags(pub ::core::ffi::c_uint);
impl ImGuiConfigFlags {
    pub const None: ImGuiConfigFlags = ImGuiConfigFlags(0);
    pub const NavEnableKeyboard: ImGuiConfigFlags = ImGuiConfigFlags(1);
    pub const NavEnableGamepad: ImGuiConfigFlags = ImGuiConfigFlags(2);
    pub const NoMouse: ImGuiConfigFlags = ImGuiConfigFlags(16);
    pub const NoMouseCursorChange: ImGuiConfigFlags = ImGuiConfigFlags(32);
    pub const NoKeyboard: ImGuiConfigFlags = ImGuiConfigFlags(64);
    pub const IsSRGB: ImGuiConfigFlags = ImGuiConfigFlags(1048576);
    pub const IsTouchScreen: ImGuiConfigFlags = ImGuiConfigFlags(2097152);
}
impl ::core::ops::BitOr<ImGuiConfigFlags> for ImGuiConfigFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiConfigFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiConfigFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiConfigFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiConfigFlags> for ImGuiConfigFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiConfigFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiConfigFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiConfigFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiConfigFlags(pub ::core::ffi::c_uint);
impl ImGuiBackendFlags {
    pub const None: ImGuiBackendFlags = ImGuiBackendFlags(0);
    pub const HasGamepad: ImGuiBackendFlags = ImGuiBackendFlags(1);
    pub const HasMouseCursors: ImGuiBackendFlags = ImGuiBackendFlags(2);
    pub const HasSetMousePos: ImGuiBackendFlags = ImGuiBackendFlags(4);
    pub const RendererHasVtxOffset: ImGuiBackendFlags = ImGuiBackendFlags(8);
    pub const RendererHasTextures: ImGuiBackendFlags = ImGuiBackendFlags(16);
}
impl ::core::ops::BitOr<ImGuiBackendFlags> for ImGuiBackendFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiBackendFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiBackendFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiBackendFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiBackendFlags> for ImGuiBackendFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiBackendFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiBackendFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiBackendFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiBackendFlags(pub ::core::ffi::c_uint);
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ImGuiCol {
    Text = 0,
    TextDisabled = 1,
    WindowBg = 2,
    ChildBg = 3,
    PopupBg = 4,
    Border = 5,
    BorderShadow = 6,
    FrameBg = 7,
    FrameBgHovered = 8,
    FrameBgActive = 9,
    TitleBg = 10,
    TitleBgActive = 11,
    TitleBgCollapsed = 12,
    MenuBarBg = 13,
    ScrollbarBg = 14,
    ScrollbarGrab = 15,
    ScrollbarGrabHovered = 16,
    ScrollbarGrabActive = 17,
    CheckMark = 18,
    CheckboxSelectedBg = 19,
    SliderGrab = 20,
    SliderGrabActive = 21,
    Button = 22,
    ButtonHovered = 23,
    ButtonActive = 24,
    Header = 25,
    HeaderHovered = 26,
    HeaderActive = 27,
    Separator = 28,
    SeparatorHovered = 29,
    SeparatorActive = 30,
    ResizeGrip = 31,
    ResizeGripHovered = 32,
    ResizeGripActive = 33,
    InputTextCursor = 34,
    TabHovered = 35,
    Tab = 36,
    TabSelected = 37,
    TabSelectedOverline = 38,
    TabDimmed = 39,
    TabDimmedSelected = 40,
    TabDimmedSelectedOverline = 41,
    PlotLines = 42,
    PlotLinesHovered = 43,
    PlotHistogram = 44,
    PlotHistogramHovered = 45,
    TableHeaderBg = 46,
    TableBorderStrong = 47,
    TableBorderLight = 48,
    TableRowBg = 49,
    TableRowBgAlt = 50,
    TextLink = 51,
    TextSelectedBg = 52,
    TreeLines = 53,
    DragDropTarget = 54,
    DragDropTargetBg = 55,
    UnsavedMarker = 56,
    NavCursor = 57,
    NavWindowingHighlight = 58,
    NavWindowingDimBg = 59,
    ModalWindowDimBg = 60,
    COUNT = 61,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ImGuiStyleVar {
    Alpha = 0,
    DisabledAlpha = 1,
    WindowPadding = 2,
    WindowRounding = 3,
    WindowBorderSize = 4,
    WindowMinSize = 5,
    WindowTitleAlign = 6,
    ChildRounding = 7,
    ChildBorderSize = 8,
    PopupRounding = 9,
    PopupBorderSize = 10,
    FramePadding = 11,
    FrameRounding = 12,
    FrameBorderSize = 13,
    ItemSpacing = 14,
    ItemInnerSpacing = 15,
    IndentSpacing = 16,
    CellPadding = 17,
    ScrollbarSize = 18,
    ScrollbarRounding = 19,
    ScrollbarPadding = 20,
    GrabMinSize = 21,
    GrabRounding = 22,
    ImageRounding = 23,
    ImageBorderSize = 24,
    TabRounding = 25,
    TabBorderSize = 26,
    TabMinWidthBase = 27,
    TabMinWidthShrink = 28,
    TabBarBorderSize = 29,
    TabBarOverlineSize = 30,
    TableAngledHeadersAngle = 31,
    TableAngledHeadersTextAlign = 32,
    TreeLinesSize = 33,
    TreeLinesRounding = 34,
    DragDropTargetRounding = 35,
    ButtonTextAlign = 36,
    SelectableTextAlign = 37,
    SeparatorSize = 38,
    SeparatorTextBorderSize = 39,
    SeparatorTextAlign = 40,
    SeparatorTextPadding = 41,
    COUNT = 42,
}
impl ImGuiButtonFlags {
    pub const None: ImGuiButtonFlags = ImGuiButtonFlags(0);
    pub const MouseButtonLeft: ImGuiButtonFlags = ImGuiButtonFlags(1);
    pub const MouseButtonRight: ImGuiButtonFlags = ImGuiButtonFlags(2);
    pub const MouseButtonMiddle: ImGuiButtonFlags = ImGuiButtonFlags(4);
    pub const MouseButtonMask_: ImGuiButtonFlags = ImGuiButtonFlags(7);
    pub const EnableNav: ImGuiButtonFlags = ImGuiButtonFlags(8);
    pub const AllowOverlap: ImGuiButtonFlags = ImGuiButtonFlags(4096);
}
impl ::core::ops::BitOr<ImGuiButtonFlags> for ImGuiButtonFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiButtonFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiButtonFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiButtonFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiButtonFlags> for ImGuiButtonFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiButtonFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiButtonFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiButtonFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiButtonFlags(pub ::core::ffi::c_uint);
impl ImGuiColorEditFlags {
    pub const None: ImGuiColorEditFlags = ImGuiColorEditFlags(0);
    pub const NoAlpha: ImGuiColorEditFlags = ImGuiColorEditFlags(2);
    pub const NoPicker: ImGuiColorEditFlags = ImGuiColorEditFlags(4);
    pub const NoOptions: ImGuiColorEditFlags = ImGuiColorEditFlags(8);
    pub const NoSmallPreview: ImGuiColorEditFlags = ImGuiColorEditFlags(16);
    pub const NoInputs: ImGuiColorEditFlags = ImGuiColorEditFlags(32);
    pub const NoTooltip: ImGuiColorEditFlags = ImGuiColorEditFlags(64);
    pub const NoLabel: ImGuiColorEditFlags = ImGuiColorEditFlags(128);
    pub const NoSidePreview: ImGuiColorEditFlags = ImGuiColorEditFlags(256);
    pub const NoDragDrop: ImGuiColorEditFlags = ImGuiColorEditFlags(512);
    pub const NoBorder: ImGuiColorEditFlags = ImGuiColorEditFlags(1024);
    pub const NoColorMarkers: ImGuiColorEditFlags = ImGuiColorEditFlags(2048);
    pub const AlphaOpaque: ImGuiColorEditFlags = ImGuiColorEditFlags(4096);
    pub const AlphaNoBg: ImGuiColorEditFlags = ImGuiColorEditFlags(8192);
    pub const AlphaPreviewHalf: ImGuiColorEditFlags = ImGuiColorEditFlags(16384);
    pub const AlphaBar: ImGuiColorEditFlags = ImGuiColorEditFlags(262144);
    pub const HDR: ImGuiColorEditFlags = ImGuiColorEditFlags(524288);
    pub const DisplayRGB: ImGuiColorEditFlags = ImGuiColorEditFlags(1048576);
    pub const DisplayHSV: ImGuiColorEditFlags = ImGuiColorEditFlags(2097152);
    pub const DisplayHex: ImGuiColorEditFlags = ImGuiColorEditFlags(4194304);
    pub const Uint8: ImGuiColorEditFlags = ImGuiColorEditFlags(8388608);
    pub const Float: ImGuiColorEditFlags = ImGuiColorEditFlags(16777216);
    pub const PickerHueBar: ImGuiColorEditFlags = ImGuiColorEditFlags(33554432);
    pub const PickerHueWheel: ImGuiColorEditFlags = ImGuiColorEditFlags(67108864);
    pub const InputRGB: ImGuiColorEditFlags = ImGuiColorEditFlags(134217728);
    pub const InputHSV: ImGuiColorEditFlags = ImGuiColorEditFlags(268435456);
    pub const DefaultOptions_: ImGuiColorEditFlags = ImGuiColorEditFlags(177209344);
    pub const AlphaMask_: ImGuiColorEditFlags = ImGuiColorEditFlags(28674);
    pub const DisplayMask_: ImGuiColorEditFlags = ImGuiColorEditFlags(7340032);
    pub const DataTypeMask_: ImGuiColorEditFlags = ImGuiColorEditFlags(25165824);
    pub const PickerMask_: ImGuiColorEditFlags = ImGuiColorEditFlags(100663296);
    pub const InputMask_: ImGuiColorEditFlags = ImGuiColorEditFlags(402653184);
}
impl ::core::ops::BitOr<ImGuiColorEditFlags> for ImGuiColorEditFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiColorEditFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiColorEditFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiColorEditFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiColorEditFlags> for ImGuiColorEditFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiColorEditFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiColorEditFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiColorEditFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiColorEditFlags(pub ::core::ffi::c_uint);
impl ImGuiSliderFlags {
    pub const None: ImGuiSliderFlags = ImGuiSliderFlags(0);
    pub const Logarithmic: ImGuiSliderFlags = ImGuiSliderFlags(32);
    pub const NoRoundToFormat: ImGuiSliderFlags = ImGuiSliderFlags(64);
    pub const NoInput: ImGuiSliderFlags = ImGuiSliderFlags(128);
    pub const WrapAround: ImGuiSliderFlags = ImGuiSliderFlags(256);
    pub const ClampOnInput: ImGuiSliderFlags = ImGuiSliderFlags(512);
    pub const ClampZeroRange: ImGuiSliderFlags = ImGuiSliderFlags(1024);
    pub const NoSpeedTweaks: ImGuiSliderFlags = ImGuiSliderFlags(2048);
    pub const ColorMarkers: ImGuiSliderFlags = ImGuiSliderFlags(4096);
    pub const AlwaysClamp: ImGuiSliderFlags = ImGuiSliderFlags(1536);
    pub const InvalidMask_: ImGuiSliderFlags = ImGuiSliderFlags(1879048207);
}
impl ::core::ops::BitOr<ImGuiSliderFlags> for ImGuiSliderFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiSliderFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiSliderFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiSliderFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiSliderFlags> for ImGuiSliderFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiSliderFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiSliderFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiSliderFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiSliderFlags(pub ::core::ffi::c_uint);
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ImGuiMouseButton {
    Left = 0,
    Right = 1,
    Middle = 2,
    COUNT = 5,
}
#[repr(i32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ImGuiMouseCursor {
    None = -1,
    Arrow = 0,
    TextInput = 1,
    ResizeAll = 2,
    ResizeNS = 3,
    ResizeEW = 4,
    ResizeNESW = 5,
    ResizeNWSE = 6,
    Hand = 7,
    Wait = 8,
    Progress = 9,
    NotAllowed = 10,
    COUNT = 11,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ImGuiMouseSource {
    Mouse = 0,
    TouchScreen = 1,
    Pen = 2,
    COUNT = 3,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ImGuiCond {
    None = 0,
    Always = 1,
    Once = 2,
    FirstUseEver = 4,
    Appearing = 8,
}
impl ImGuiTableFlags {
    pub const None: ImGuiTableFlags = ImGuiTableFlags(0);
    pub const Resizable: ImGuiTableFlags = ImGuiTableFlags(1);
    pub const Reorderable: ImGuiTableFlags = ImGuiTableFlags(2);
    pub const Hideable: ImGuiTableFlags = ImGuiTableFlags(4);
    pub const Sortable: ImGuiTableFlags = ImGuiTableFlags(8);
    pub const NoSavedSettings: ImGuiTableFlags = ImGuiTableFlags(16);
    pub const ContextMenuInBody: ImGuiTableFlags = ImGuiTableFlags(32);
    pub const RowBg: ImGuiTableFlags = ImGuiTableFlags(64);
    pub const BordersInnerH: ImGuiTableFlags = ImGuiTableFlags(128);
    pub const BordersOuterH: ImGuiTableFlags = ImGuiTableFlags(256);
    pub const BordersInnerV: ImGuiTableFlags = ImGuiTableFlags(512);
    pub const BordersOuterV: ImGuiTableFlags = ImGuiTableFlags(1024);
    pub const BordersH: ImGuiTableFlags = ImGuiTableFlags(384);
    pub const BordersV: ImGuiTableFlags = ImGuiTableFlags(1536);
    pub const BordersInner: ImGuiTableFlags = ImGuiTableFlags(640);
    pub const BordersOuter: ImGuiTableFlags = ImGuiTableFlags(1280);
    pub const Borders: ImGuiTableFlags = ImGuiTableFlags(1920);
    pub const NoBordersInBody: ImGuiTableFlags = ImGuiTableFlags(2048);
    pub const NoBordersInBodyUntilResize: ImGuiTableFlags = ImGuiTableFlags(4096);
    pub const SizingFixedFit: ImGuiTableFlags = ImGuiTableFlags(8192);
    pub const SizingFixedSame: ImGuiTableFlags = ImGuiTableFlags(16384);
    pub const SizingStretchProp: ImGuiTableFlags = ImGuiTableFlags(24576);
    pub const SizingStretchSame: ImGuiTableFlags = ImGuiTableFlags(32768);
    pub const NoHostExtendX: ImGuiTableFlags = ImGuiTableFlags(65536);
    pub const NoHostExtendY: ImGuiTableFlags = ImGuiTableFlags(131072);
    pub const NoKeepColumnsVisible: ImGuiTableFlags = ImGuiTableFlags(262144);
    pub const PreciseWidths: ImGuiTableFlags = ImGuiTableFlags(524288);
    pub const NoClip: ImGuiTableFlags = ImGuiTableFlags(1048576);
    pub const PadOuterX: ImGuiTableFlags = ImGuiTableFlags(2097152);
    pub const NoPadOuterX: ImGuiTableFlags = ImGuiTableFlags(4194304);
    pub const NoPadInnerX: ImGuiTableFlags = ImGuiTableFlags(8388608);
    pub const ScrollX: ImGuiTableFlags = ImGuiTableFlags(16777216);
    pub const ScrollY: ImGuiTableFlags = ImGuiTableFlags(33554432);
    pub const SortMulti: ImGuiTableFlags = ImGuiTableFlags(67108864);
    pub const SortTristate: ImGuiTableFlags = ImGuiTableFlags(134217728);
    pub const HighlightHoveredColumn: ImGuiTableFlags = ImGuiTableFlags(268435456);
    pub const SizingMask_: ImGuiTableFlags = ImGuiTableFlags(57344);
}
impl ::core::ops::BitOr<ImGuiTableFlags> for ImGuiTableFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiTableFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiTableFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiTableFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiTableFlags> for ImGuiTableFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiTableFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiTableFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiTableFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiTableFlags(pub ::core::ffi::c_uint);
impl ImGuiTableColumnFlags {
    pub const None: ImGuiTableColumnFlags = ImGuiTableColumnFlags(0);
    pub const Disabled: ImGuiTableColumnFlags = ImGuiTableColumnFlags(1);
    pub const DefaultHide: ImGuiTableColumnFlags = ImGuiTableColumnFlags(2);
    pub const DefaultSort: ImGuiTableColumnFlags = ImGuiTableColumnFlags(4);
    pub const WidthStretch: ImGuiTableColumnFlags = ImGuiTableColumnFlags(8);
    pub const WidthFixed: ImGuiTableColumnFlags = ImGuiTableColumnFlags(16);
    pub const NoResize: ImGuiTableColumnFlags = ImGuiTableColumnFlags(32);
    pub const NoReorder: ImGuiTableColumnFlags = ImGuiTableColumnFlags(64);
    pub const NoHide: ImGuiTableColumnFlags = ImGuiTableColumnFlags(128);
    pub const NoClip: ImGuiTableColumnFlags = ImGuiTableColumnFlags(256);
    pub const NoSort: ImGuiTableColumnFlags = ImGuiTableColumnFlags(512);
    pub const NoSortAscending: ImGuiTableColumnFlags = ImGuiTableColumnFlags(1024);
    pub const NoSortDescending: ImGuiTableColumnFlags = ImGuiTableColumnFlags(2048);
    pub const NoHeaderLabel: ImGuiTableColumnFlags = ImGuiTableColumnFlags(4096);
    pub const NoHeaderWidth: ImGuiTableColumnFlags = ImGuiTableColumnFlags(8192);
    pub const PreferSortAscending: ImGuiTableColumnFlags = ImGuiTableColumnFlags(16384);
    pub const PreferSortDescending: ImGuiTableColumnFlags = ImGuiTableColumnFlags(32768);
    pub const IndentEnable: ImGuiTableColumnFlags = ImGuiTableColumnFlags(65536);
    pub const IndentDisable: ImGuiTableColumnFlags = ImGuiTableColumnFlags(131072);
    pub const AngledHeader: ImGuiTableColumnFlags = ImGuiTableColumnFlags(262144);
    pub const IsEnabled: ImGuiTableColumnFlags = ImGuiTableColumnFlags(16777216);
    pub const IsVisible: ImGuiTableColumnFlags = ImGuiTableColumnFlags(33554432);
    pub const IsSorted: ImGuiTableColumnFlags = ImGuiTableColumnFlags(67108864);
    pub const IsHovered: ImGuiTableColumnFlags = ImGuiTableColumnFlags(134217728);
    pub const WidthMask_: ImGuiTableColumnFlags = ImGuiTableColumnFlags(24);
    pub const IndentMask_: ImGuiTableColumnFlags = ImGuiTableColumnFlags(196608);
    pub const StatusMask_: ImGuiTableColumnFlags = ImGuiTableColumnFlags(251658240);
    pub const NoDirectResize_: ImGuiTableColumnFlags = ImGuiTableColumnFlags(1073741824);
}
impl ::core::ops::BitOr<ImGuiTableColumnFlags> for ImGuiTableColumnFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiTableColumnFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiTableColumnFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiTableColumnFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiTableColumnFlags> for ImGuiTableColumnFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiTableColumnFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiTableColumnFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiTableColumnFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiTableColumnFlags(pub ::core::ffi::c_uint);
impl ImGuiTableRowFlags {
    pub const None: ImGuiTableRowFlags = ImGuiTableRowFlags(0);
    pub const Headers: ImGuiTableRowFlags = ImGuiTableRowFlags(1);
}
impl ::core::ops::BitOr<ImGuiTableRowFlags> for ImGuiTableRowFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiTableRowFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiTableRowFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiTableRowFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiTableRowFlags> for ImGuiTableRowFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiTableRowFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiTableRowFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiTableRowFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiTableRowFlags(pub ::core::ffi::c_uint);
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ImGuiTableBgTarget {
    None = 0,
    RowBg0 = 1,
    RowBg1 = 2,
    CellBg = 3,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiTableSortSpecs {
    pub Specs: *const ImGuiTableColumnSortSpecs,
    pub SpecsCount: ::core::ffi::c_int,
    pub SpecsDirty: bool,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiTableColumnSortSpecs {
    pub ColumnUserID: ImGuiID,
    pub ColumnIndex: ImS16,
    pub SortOrder: ImS16,
    pub SortDirection: ImGuiSortDirection,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiStyle {
    pub FontSizeBase: f32,
    pub FontScaleMain: f32,
    pub FontScaleDpi: f32,
    pub Alpha: f32,
    pub DisabledAlpha: f32,
    pub WindowPadding: ImVec2_c,
    pub WindowRounding: f32,
    pub WindowBorderSize: f32,
    pub WindowBorderHoverPadding: f32,
    pub WindowMinSize: ImVec2_c,
    pub WindowTitleAlign: ImVec2_c,
    pub WindowMenuButtonPosition: ImGuiDir,
    pub ChildRounding: f32,
    pub ChildBorderSize: f32,
    pub PopupRounding: f32,
    pub PopupBorderSize: f32,
    pub FramePadding: ImVec2_c,
    pub FrameRounding: f32,
    pub FrameBorderSize: f32,
    pub ItemSpacing: ImVec2_c,
    pub ItemInnerSpacing: ImVec2_c,
    pub CellPadding: ImVec2_c,
    pub TouchExtraPadding: ImVec2_c,
    pub IndentSpacing: f32,
    pub ColumnsMinSpacing: f32,
    pub ScrollbarSize: f32,
    pub ScrollbarRounding: f32,
    pub ScrollbarPadding: f32,
    pub GrabMinSize: f32,
    pub GrabRounding: f32,
    pub LogSliderDeadzone: f32,
    pub ImageRounding: f32,
    pub ImageBorderSize: f32,
    pub TabRounding: f32,
    pub TabBorderSize: f32,
    pub TabMinWidthBase: f32,
    pub TabMinWidthShrink: f32,
    pub TabCloseButtonMinWidthSelected: f32,
    pub TabCloseButtonMinWidthUnselected: f32,
    pub TabBarBorderSize: f32,
    pub TabBarOverlineSize: f32,
    pub TableAngledHeadersAngle: f32,
    pub TableAngledHeadersTextAlign: ImVec2_c,
    pub TreeLinesFlags: ImGuiTreeNodeFlags,
    pub TreeLinesSize: f32,
    pub TreeLinesRounding: f32,
    pub DragDropTargetRounding: f32,
    pub DragDropTargetBorderSize: f32,
    pub DragDropTargetPadding: f32,
    pub ColorMarkerSize: f32,
    pub ColorButtonPosition: ImGuiDir,
    pub ButtonTextAlign: ImVec2_c,
    pub SelectableTextAlign: ImVec2_c,
    pub SeparatorSize: f32,
    pub SeparatorTextBorderSize: f32,
    pub SeparatorTextAlign: ImVec2_c,
    pub SeparatorTextPadding: ImVec2_c,
    pub DisplayWindowPadding: ImVec2_c,
    pub DisplaySafeAreaPadding: ImVec2_c,
    pub MouseCursorScale: f32,
    pub AntiAliasedLines: bool,
    pub AntiAliasedLinesUseTex: bool,
    pub AntiAliasedFill: bool,
    pub CurveTessellationTol: f32,
    pub CircleTessellationMaxError: f32,
    pub Colors: [ImVec4_c; 61usize],
    pub HoverStationaryDelay: f32,
    pub HoverDelayShort: f32,
    pub HoverDelayNormal: f32,
    pub HoverFlagsForTooltipMouse: ImGuiHoveredFlags,
    pub HoverFlagsForTooltipNav: ImGuiHoveredFlags,
    pub _MainScale: f32,
    pub _NextFrameFontSizeBase: f32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiKeyData {
    pub Down: bool,
    pub DownDuration: f32,
    pub DownDurationPrev: f32,
    pub AnalogValue: f32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImWchar {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImWchar,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiIO {
    pub ConfigFlags: ImGuiConfigFlags,
    pub BackendFlags: ImGuiBackendFlags,
    pub DisplaySize: ImVec2_c,
    pub DisplayFramebufferScale: ImVec2_c,
    pub DeltaTime: f32,
    pub IniSavingRate: f32,
    pub IniFilename: *const ::core::ffi::c_char,
    pub LogFilename: *const ::core::ffi::c_char,
    pub UserData: *mut ::core::ffi::c_void,
    pub Fonts: *mut ImFontAtlas,
    pub FontDefault: *mut ImFont,
    pub FontAllowUserScaling: bool,
    pub ConfigNavSwapGamepadButtons: bool,
    pub ConfigNavMoveSetMousePos: bool,
    pub ConfigNavCaptureKeyboard: bool,
    pub ConfigNavEscapeClearFocusItem: bool,
    pub ConfigNavEscapeClearFocusWindow: bool,
    pub ConfigNavCursorVisibleAuto: bool,
    pub ConfigNavCursorVisibleAlways: bool,
    pub MouseDrawCursor: bool,
    pub ConfigMacOSXBehaviors: bool,
    pub ConfigInputTrickleEventQueue: bool,
    pub ConfigInputTextCursorBlink: bool,
    pub ConfigInputTextEnterKeepActive: bool,
    pub ConfigDragClickToInputText: bool,
    pub ConfigWindowsResizeFromEdges: bool,
    pub ConfigWindowsMoveFromTitleBarOnly: bool,
    pub ConfigWindowsCopyContentsWithCtrlC: bool,
    pub ConfigScrollbarScrollByPage: bool,
    pub ConfigMemoryCompactTimer: f32,
    pub MouseDoubleClickTime: f32,
    pub MouseDoubleClickMaxDist: f32,
    pub MouseDragThreshold: f32,
    pub KeyRepeatDelay: f32,
    pub KeyRepeatRate: f32,
    pub ConfigErrorRecovery: bool,
    pub ConfigErrorRecoveryEnableAssert: bool,
    pub ConfigErrorRecoveryEnableDebugLog: bool,
    pub ConfigErrorRecoveryEnableTooltip: bool,
    pub ConfigDebugIsDebuggerPresent: bool,
    pub ConfigDebugHighlightIdConflicts: bool,
    pub ConfigDebugHighlightIdConflictsShowItemPicker: bool,
    pub ConfigDebugBeginReturnValueOnce: bool,
    pub ConfigDebugBeginReturnValueLoop: bool,
    pub ConfigDebugIgnoreFocusLoss: bool,
    pub ConfigDebugIniSettings: bool,
    pub BackendPlatformName: *const ::core::ffi::c_char,
    pub BackendRendererName: *const ::core::ffi::c_char,
    pub BackendPlatformUserData: *mut ::core::ffi::c_void,
    pub BackendRendererUserData: *mut ::core::ffi::c_void,
    pub BackendLanguageUserData: *mut ::core::ffi::c_void,
    pub WantCaptureMouse: bool,
    pub WantCaptureKeyboard: bool,
    pub WantTextInput: bool,
    pub WantSetMousePos: bool,
    pub WantSaveIniSettings: bool,
    pub NavActive: bool,
    pub NavVisible: bool,
    pub Framerate: f32,
    pub MetricsRenderVertices: ::core::ffi::c_int,
    pub MetricsRenderIndices: ::core::ffi::c_int,
    pub MetricsRenderWindows: ::core::ffi::c_int,
    pub MetricsActiveWindows: ::core::ffi::c_int,
    pub MouseDelta: ImVec2_c,
    pub Ctx: *mut ImGuiContext,
    pub MousePos: ImVec2_c,
    pub MouseDown: [bool; 5usize],
    pub MouseWheel: f32,
    pub MouseWheelH: f32,
    pub MouseSource: ImGuiMouseSource,
    pub KeyCtrl: bool,
    pub KeyShift: bool,
    pub KeyAlt: bool,
    pub KeySuper: bool,
    pub KeyMods: ImGuiKeyChord,
    pub KeysData: [ImGuiKeyData; 155usize],
    pub WantCaptureMouseUnlessPopupClose: bool,
    pub MousePosPrev: ImVec2_c,
    pub MouseClickedPos: [ImVec2_c; 5usize],
    pub MouseClickedTime: [f64; 5usize],
    pub MouseClicked: [bool; 5usize],
    pub MouseDoubleClicked: [bool; 5usize],
    pub MouseClickedCount: [ImU16; 5usize],
    pub MouseClickedLastCount: [ImU16; 5usize],
    pub MouseReleased: [bool; 5usize],
    pub MouseReleasedTime: [f64; 5usize],
    pub MouseDownOwned: [bool; 5usize],
    pub MouseDownOwnedUnlessPopupClose: [bool; 5usize],
    pub MouseWheelRequestAxisSwap: bool,
    pub MouseCtrlLeftAsRightClick: bool,
    pub MouseDownDuration: [f32; 5usize],
    pub MouseDownDurationPrev: [f32; 5usize],
    pub MouseDragMaxDistanceSqr: [f32; 5usize],
    pub PenPressure: f32,
    pub AppFocusLost: bool,
    pub AppAcceptingEvents: bool,
    pub InputQueueSurrogate: ImWchar16,
    pub InputQueueCharacters: ImVector_ImWchar,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiInputTextCallbackData {
    pub Ctx: *mut ImGuiContext,
    pub EventFlag: ImGuiInputTextFlags,
    pub Flags: ImGuiInputTextFlags,
    pub UserData: *mut ::core::ffi::c_void,
    pub ID: ImGuiID,
    pub EventKey: ImGuiKey,
    pub EventChar: ImWchar,
    pub EventActivated: bool,
    pub BufDirty: bool,
    pub Buf: *mut ::core::ffi::c_char,
    pub BufTextLen: ::core::ffi::c_int,
    pub BufSize: ::core::ffi::c_int,
    pub CursorPos: ::core::ffi::c_int,
    pub SelectionStart: ::core::ffi::c_int,
    pub SelectionEnd: ::core::ffi::c_int,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiSizeCallbackData {
    pub UserData: *mut ::core::ffi::c_void,
    pub Pos: ImVec2_c,
    pub CurrentSize: ImVec2_c,
    pub DesiredSize: ImVec2_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiPayload {
    pub Data: *mut ::core::ffi::c_void,
    pub DataSize: ::core::ffi::c_int,
    pub SourceId: ImGuiID,
    pub SourceParentId: ImGuiID,
    pub DataFrameCount: ::core::ffi::c_int,
    pub DataType: [::core::ffi::c_char; 33usize],
    pub Preview: bool,
    pub Delivery: bool,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiOnceUponAFrame {
    pub RefFrame: ::core::ffi::c_int,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiTextRange {
    pub b: *const ::core::ffi::c_char,
    pub e: *const ::core::ffi::c_char,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiTextRange {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiTextRange,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiTextFilter {
    pub InputBuf: [::core::ffi::c_char; 256usize],
    pub Filters: ImVector_ImGuiTextRange,
    pub CountGrep: ::core::ffi::c_int,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_char {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ::core::ffi::c_char,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiTextBuffer {
    pub Buf: ImVector_char,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ImGuiStoragePair {
    pub key: ImGuiID,
    pub __bindgen_anon_1: ImGuiStoragePair__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union ImGuiStoragePair__bindgen_ty_1 {
    pub val_i: ::core::ffi::c_int,
    pub val_f: f32,
    pub val_p: *mut ::core::ffi::c_void,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiStoragePair {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiStoragePair,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiStorage {
    pub Data: ImVector_ImGuiStoragePair,
}
impl ImGuiListClipperFlags {
    pub const None: ImGuiListClipperFlags = ImGuiListClipperFlags(0);
    pub const NoSetTableRowCounters: ImGuiListClipperFlags = ImGuiListClipperFlags(1);
}
impl ::core::ops::BitOr<ImGuiListClipperFlags> for ImGuiListClipperFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiListClipperFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiListClipperFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiListClipperFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiListClipperFlags> for ImGuiListClipperFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiListClipperFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiListClipperFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiListClipperFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiListClipperFlags(pub ::core::ffi::c_uint);
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiListClipper {
    pub DisplayStart: ::core::ffi::c_int,
    pub DisplayEnd: ::core::ffi::c_int,
    pub UserIndex: ::core::ffi::c_int,
    pub ItemsCount: ::core::ffi::c_int,
    pub ItemsHeight: f32,
    pub Flags: ImGuiListClipperFlags,
    pub StartPosY: f64,
    pub StartSeekOffsetY: f64,
    pub Ctx: *mut ImGuiContext,
    pub TempData: *mut ::core::ffi::c_void,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImColor_c {
    pub Value: ImVec4_c,
}
impl ImGuiMultiSelectFlags {
    pub const None: ImGuiMultiSelectFlags = ImGuiMultiSelectFlags(0);
    pub const SingleSelect: ImGuiMultiSelectFlags = ImGuiMultiSelectFlags(1);
    pub const NoSelectAll: ImGuiMultiSelectFlags = ImGuiMultiSelectFlags(2);
    pub const NoRangeSelect: ImGuiMultiSelectFlags = ImGuiMultiSelectFlags(4);
    pub const NoAutoSelect: ImGuiMultiSelectFlags = ImGuiMultiSelectFlags(8);
    pub const NoAutoClear: ImGuiMultiSelectFlags = ImGuiMultiSelectFlags(16);
    pub const NoAutoClearOnReselect: ImGuiMultiSelectFlags = ImGuiMultiSelectFlags(32);
    pub const BoxSelect1d: ImGuiMultiSelectFlags = ImGuiMultiSelectFlags(64);
    pub const BoxSelect2d: ImGuiMultiSelectFlags = ImGuiMultiSelectFlags(128);
    pub const BoxSelectNoScroll: ImGuiMultiSelectFlags = ImGuiMultiSelectFlags(256);
    pub const ClearOnEscape: ImGuiMultiSelectFlags = ImGuiMultiSelectFlags(512);
    pub const ClearOnClickVoid: ImGuiMultiSelectFlags = ImGuiMultiSelectFlags(1024);
    pub const ScopeWindow: ImGuiMultiSelectFlags = ImGuiMultiSelectFlags(2048);
    pub const ScopeRect: ImGuiMultiSelectFlags = ImGuiMultiSelectFlags(4096);
    pub const SelectOnAuto: ImGuiMultiSelectFlags = ImGuiMultiSelectFlags(8192);
    pub const SelectOnClickAlways: ImGuiMultiSelectFlags = ImGuiMultiSelectFlags(16384);
    pub const SelectOnClickRelease: ImGuiMultiSelectFlags = ImGuiMultiSelectFlags(32768);
    pub const NavWrapX: ImGuiMultiSelectFlags = ImGuiMultiSelectFlags(65536);
    pub const NoSelectOnRightClick: ImGuiMultiSelectFlags = ImGuiMultiSelectFlags(131072);
    pub const SelectOnMask_: ImGuiMultiSelectFlags = ImGuiMultiSelectFlags(57344);
}
impl ::core::ops::BitOr<ImGuiMultiSelectFlags> for ImGuiMultiSelectFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiMultiSelectFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiMultiSelectFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiMultiSelectFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiMultiSelectFlags> for ImGuiMultiSelectFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiMultiSelectFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiMultiSelectFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiMultiSelectFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiMultiSelectFlags(pub ::core::ffi::c_uint);
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiSelectionRequest {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiSelectionRequest,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiMultiSelectIO {
    pub Requests: ImVector_ImGuiSelectionRequest,
    pub RangeSrcItem: ImGuiSelectionUserData,
    pub NavIdItem: ImGuiSelectionUserData,
    pub NavIdSelected: bool,
    pub RangeSrcReset: bool,
    pub ItemsCount: ::core::ffi::c_int,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ImGuiSelectionRequestType {
    None = 0,
    SetAll = 1,
    SetRange = 2,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiSelectionRequest {
    pub Type: ImGuiSelectionRequestType,
    pub Selected: bool,
    pub RangeDirection: ImS8,
    pub RangeFirstItem: ImGuiSelectionUserData,
    pub RangeLastItem: ImGuiSelectionUserData,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiSelectionBasicStorage {
    pub Size: ::core::ffi::c_int,
    pub PreserveOrder: bool,
    pub UserData: *mut ::core::ffi::c_void,
    pub AdapterIndexToStorageId:
        ::core::option::Option<unsafe extern "C" fn(self_: *mut ImGuiSelectionBasicStorage, idx: ::core::ffi::c_int) -> ImGuiID>,
    pub _SelectionOrder: ::core::ffi::c_int,
    pub _Storage: ImGuiStorage,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiSelectionExternalStorage {
    pub UserData: *mut ::core::ffi::c_void,
    pub AdapterSetItemSelected: ::core::option::Option<
        unsafe extern "C" fn(self_: *mut ImGuiSelectionExternalStorage, idx: ::core::ffi::c_int, selected: bool),
    >,
}
pub type ImDrawIdx = ::core::ffi::c_ushort;
pub type ImDrawCallback = ::core::option::Option<unsafe extern "C" fn(parent_list: *const ImDrawList, cmd: *const ImDrawCmd)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImDrawCmd {
    pub ClipRect: ImVec4_c,
    pub TexRef: ImTextureRef_c,
    pub VtxOffset: ::core::ffi::c_uint,
    pub IdxOffset: ::core::ffi::c_uint,
    pub ElemCount: ::core::ffi::c_uint,
    pub UserCallback: ImDrawCallback,
    pub UserCallbackData: *mut ::core::ffi::c_void,
    pub UserCallbackDataSize: ::core::ffi::c_int,
    pub UserCallbackDataOffset: ::core::ffi::c_int,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImDrawVert {
    pub pos: ImVec2_c,
    pub uv: ImVec2_c,
    pub col: ImU32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImDrawCmdHeader {
    pub ClipRect: ImVec4_c,
    pub TexRef: ImTextureRef_c,
    pub VtxOffset: ::core::ffi::c_uint,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImDrawCmd {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImDrawCmd,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImDrawIdx {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImDrawIdx,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImDrawChannel {
    pub _CmdBuffer: ImVector_ImDrawCmd,
    pub _IdxBuffer: ImVector_ImDrawIdx,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImDrawChannel {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImDrawChannel,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImDrawListSplitter {
    pub _Current: ::core::ffi::c_int,
    pub _Count: ::core::ffi::c_int,
    pub _Channels: ImVector_ImDrawChannel,
}
impl ImDrawFlags {
    pub const None: ImDrawFlags = ImDrawFlags(0);
    pub const RoundCornersTopLeft: ImDrawFlags = ImDrawFlags(16);
    pub const RoundCornersTopRight: ImDrawFlags = ImDrawFlags(32);
    pub const RoundCornersBottomLeft: ImDrawFlags = ImDrawFlags(64);
    pub const RoundCornersBottomRight: ImDrawFlags = ImDrawFlags(128);
    pub const RoundCornersNone: ImDrawFlags = ImDrawFlags(256);
    pub const Closed: ImDrawFlags = ImDrawFlags(512);
    pub const RoundCornersTop: ImDrawFlags = ImDrawFlags(48);
    pub const RoundCornersBottom: ImDrawFlags = ImDrawFlags(192);
    pub const RoundCornersLeft: ImDrawFlags = ImDrawFlags(80);
    pub const RoundCornersRight: ImDrawFlags = ImDrawFlags(160);
    pub const RoundCornersAll: ImDrawFlags = ImDrawFlags(240);
    pub const RoundCornersDefault_: ImDrawFlags = ImDrawFlags(240);
    pub const RoundCornersMask_: ImDrawFlags = ImDrawFlags(496);
    pub const InvalidMask_: ImDrawFlags = ImDrawFlags(-2147483633);
}
impl ::core::ops::BitOr<ImDrawFlags> for ImDrawFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImDrawFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImDrawFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImDrawFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImDrawFlags> for ImDrawFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImDrawFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImDrawFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImDrawFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImDrawFlags(pub ::core::ffi::c_int);
impl ImDrawListFlags {
    pub const None: ImDrawListFlags = ImDrawListFlags(0);
    pub const AntiAliasedLines: ImDrawListFlags = ImDrawListFlags(1);
    pub const AntiAliasedLinesUseTex: ImDrawListFlags = ImDrawListFlags(2);
    pub const AntiAliasedFill: ImDrawListFlags = ImDrawListFlags(4);
    pub const AllowVtxOffset: ImDrawListFlags = ImDrawListFlags(8);
}
impl ::core::ops::BitOr<ImDrawListFlags> for ImDrawListFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImDrawListFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImDrawListFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImDrawListFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImDrawListFlags> for ImDrawListFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImDrawListFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImDrawListFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImDrawListFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImDrawListFlags(pub ::core::ffi::c_uint);
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImDrawVert {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImDrawVert,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImVec2 {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImVec2_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImVec4 {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImVec4_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImTextureRef {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImTextureRef_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImU8 {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImU8,
}
#[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 _VtxCurrentIdx: ::core::ffi::c_uint,
    pub _Data: *mut ImDrawListSharedData,
    pub _VtxWritePtr: *mut ImDrawVert,
    pub _IdxWritePtr: *mut ImDrawIdx,
    pub _Path: ImVector_ImVec2,
    pub _CmdHeader: ImDrawCmdHeader,
    pub _Splitter: ImDrawListSplitter,
    pub _ClipRectStack: ImVector_ImVec4,
    pub _TextureStack: ImVector_ImTextureRef,
    pub _CallbacksDataBuf: ImVector_ImU8,
    pub _FringeScale: f32,
    pub _OwnerName: *const ::core::ffi::c_char,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImDrawListPtr {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut *mut ImDrawList,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImTextureDataPtr {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut *mut ImTextureData,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImDrawData {
    pub Valid: bool,
    pub CmdListsCount: ::core::ffi::c_int,
    pub TotalIdxCount: ::core::ffi::c_int,
    pub TotalVtxCount: ::core::ffi::c_int,
    pub CmdLists: ImVector_ImDrawListPtr,
    pub DisplayPos: ImVec2_c,
    pub DisplaySize: ImVec2_c,
    pub FramebufferScale: ImVec2_c,
    pub OwnerViewport: *mut ImGuiViewport,
    pub Textures: *mut ImVector_ImTextureDataPtr,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ImTextureFormat {
    RGBA32 = 0,
    Alpha8 = 1,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ImTextureStatus {
    OK = 0,
    Destroyed = 1,
    WantCreate = 2,
    WantUpdates = 3,
    WantDestroy = 4,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImTextureRect {
    pub x: ::core::ffi::c_ushort,
    pub y: ::core::ffi::c_ushort,
    pub w: ::core::ffi::c_ushort,
    pub h: ::core::ffi::c_ushort,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImTextureRect {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImTextureRect,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImTextureData {
    pub UniqueID: ::core::ffi::c_int,
    pub Status: ImTextureStatus,
    pub BackendUserData: *mut ::core::ffi::c_void,
    pub TexID: ImTextureID,
    pub Format: ImTextureFormat,
    pub Width: ::core::ffi::c_int,
    pub Height: ::core::ffi::c_int,
    pub BytesPerPixel: ::core::ffi::c_int,
    pub Pixels: *mut ::core::ffi::c_uchar,
    pub UsedRect: ImTextureRect,
    pub UpdateRect: ImTextureRect,
    pub Updates: ImVector_ImTextureRect,
    pub UnusedFrames: ::core::ffi::c_int,
    pub RefCount: ::core::ffi::c_ushort,
    pub UseColors: bool,
    pub WantDestroyNextFrame: bool,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImFontConfig {
    pub Name: [::core::ffi::c_char; 40usize],
    pub FontData: *mut ::core::ffi::c_void,
    pub FontDataSize: ::core::ffi::c_int,
    pub FontDataOwnedByAtlas: bool,
    pub MergeMode: bool,
    pub PixelSnapH: bool,
    pub OversampleH: ImS8,
    pub OversampleV: ImS8,
    pub EllipsisChar: ImWchar,
    pub SizePixels: f32,
    pub GlyphRanges: *const ImWchar,
    pub GlyphExcludeRanges: *const ImWchar,
    pub GlyphOffset: ImVec2_c,
    pub GlyphMinAdvanceX: f32,
    pub GlyphMaxAdvanceX: f32,
    pub GlyphExtraAdvanceX: f32,
    pub FontNo: ImU32,
    pub FontLoaderFlags: ::core::ffi::c_uint,
    pub RasterizerMultiply: f32,
    pub RasterizerDensity: f32,
    pub ExtraSizeScale: f32,
    pub Flags: ImFontFlags,
    pub DstFont: *mut ImFont,
    pub FontLoader: *const ImFontLoader,
    pub FontLoaderData: *mut ::core::ffi::c_void,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImFontGlyph {
    pub _bitfield_align_1: [u32; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
    pub AdvanceX: f32,
    pub X0: f32,
    pub Y0: f32,
    pub X1: f32,
    pub Y1: f32,
    pub U0: f32,
    pub V0: f32,
    pub U1: f32,
    pub V1: f32,
    pub PackId: ::core::ffi::c_int,
}
impl ImFontGlyph {
    #[inline]
    pub fn Colored(&self) -> ::core::ffi::c_uint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_Colored(&mut self, val: ::core::ffi::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn Colored_raw(this: *const Self) -> ::core::ffi::c_uint {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                0usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_Colored_raw(this: *mut Self, val: ::core::ffi::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn Visible(&self) -> ::core::ffi::c_uint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_Visible(&mut self, val: ::core::ffi::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn Visible_raw(this: *const Self) -> ::core::ffi::c_uint {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                1usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_Visible_raw(this: *mut Self, val: ::core::ffi::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                1usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn SourceIdx(&self) -> ::core::ffi::c_uint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 4u8) as u32) }
    }
    #[inline]
    pub fn set_SourceIdx(&mut self, val: ::core::ffi::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(2usize, 4u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn SourceIdx_raw(this: *const Self) -> ::core::ffi::c_uint {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                2usize,
                4u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_SourceIdx_raw(this: *mut Self, val: ::core::ffi::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                2usize,
                4u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn Codepoint(&self) -> ::core::ffi::c_uint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(6usize, 26u8) as u32) }
    }
    #[inline]
    pub fn set_Codepoint(&mut self, val: ::core::ffi::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(6usize, 26u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn Codepoint_raw(this: *const Self) -> ::core::ffi::c_uint {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                6usize,
                26u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_Codepoint_raw(this: *mut Self, val: ::core::ffi::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                6usize,
                26u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        Colored: ::core::ffi::c_uint,
        Visible: ::core::ffi::c_uint,
        SourceIdx: ::core::ffi::c_uint,
        Codepoint: ::core::ffi::c_uint,
    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let Colored: u32 = unsafe { ::core::mem::transmute(Colored) };
            Colored as u64
        });
        __bindgen_bitfield_unit.set(1usize, 1u8, {
            let Visible: u32 = unsafe { ::core::mem::transmute(Visible) };
            Visible as u64
        });
        __bindgen_bitfield_unit.set(2usize, 4u8, {
            let SourceIdx: u32 = unsafe { ::core::mem::transmute(SourceIdx) };
            SourceIdx as u64
        });
        __bindgen_bitfield_unit.set(6usize, 26u8, {
            let Codepoint: u32 = unsafe { ::core::mem::transmute(Codepoint) };
            Codepoint as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImU32 {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImU32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImFontGlyphRangesBuilder {
    pub UsedChars: ImVector_ImU32,
}
pub type ImFontAtlasRectId = ::core::ffi::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImFontAtlasRect {
    pub x: ::core::ffi::c_ushort,
    pub y: ::core::ffi::c_ushort,
    pub w: ::core::ffi::c_ushort,
    pub h: ::core::ffi::c_ushort,
    pub uv0: ImVec2_c,
    pub uv1: ImVec2_c,
}
impl ImFontAtlasFlags {
    pub const None: ImFontAtlasFlags = ImFontAtlasFlags(0);
    pub const NoPowerOfTwoHeight: ImFontAtlasFlags = ImFontAtlasFlags(1);
    pub const NoMouseCursors: ImFontAtlasFlags = ImFontAtlasFlags(2);
    pub const NoBakedLines: ImFontAtlasFlags = ImFontAtlasFlags(4);
}
impl ::core::ops::BitOr<ImFontAtlasFlags> for ImFontAtlasFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImFontAtlasFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImFontAtlasFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImFontAtlasFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImFontAtlasFlags> for ImFontAtlasFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImFontAtlasFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImFontAtlasFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImFontAtlasFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImFontAtlasFlags(pub ::core::ffi::c_uint);
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImFontPtr {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut *mut ImFont,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImFontConfig {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImFontConfig,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImDrawListSharedDataPtr {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut *mut ImDrawListSharedData,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImFontAtlas {
    pub Flags: ImFontAtlasFlags,
    pub TexDesiredFormat: ImTextureFormat,
    pub TexGlyphPadding: ::core::ffi::c_int,
    pub TexMinWidth: ::core::ffi::c_int,
    pub TexMinHeight: ::core::ffi::c_int,
    pub TexMaxWidth: ::core::ffi::c_int,
    pub TexMaxHeight: ::core::ffi::c_int,
    pub UserData: *mut ::core::ffi::c_void,
    pub TexRef: ImTextureRef_c,
    pub TexData: *mut ImTextureData,
    pub TexList: ImVector_ImTextureDataPtr,
    pub Locked: bool,
    pub RendererHasTextures: bool,
    pub TexIsBuilt: bool,
    pub TexPixelsUseColors: bool,
    pub TexUvScale: ImVec2_c,
    pub TexUvWhitePixel: ImVec2_c,
    pub Fonts: ImVector_ImFontPtr,
    pub Sources: ImVector_ImFontConfig,
    pub TexUvLines: [ImVec4_c; 33usize],
    pub TexNextUniqueID: ::core::ffi::c_int,
    pub FontNextUniqueID: ::core::ffi::c_int,
    pub DrawListSharedDatas: ImVector_ImDrawListSharedDataPtr,
    pub Builder: *mut ImFontAtlasBuilder,
    pub FontLoader: *const ImFontLoader,
    pub FontLoaderName: *const ::core::ffi::c_char,
    pub FontLoaderData: *mut ::core::ffi::c_void,
    pub FontLoaderFlags: ::core::ffi::c_uint,
    pub RefCount: ::core::ffi::c_int,
    pub OwnerContext: *mut ImGuiContext,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_float {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut f32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImU16 {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImU16,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImFontGlyph {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImFontGlyph,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImFontBaked {
    pub IndexAdvanceX: ImVector_float,
    pub FallbackAdvanceX: f32,
    pub Size: f32,
    pub RasterizerDensity: f32,
    pub IndexLookup: ImVector_ImU16,
    pub Glyphs: ImVector_ImFontGlyph,
    pub FallbackGlyphIndex: ::core::ffi::c_int,
    pub Ascent: f32,
    pub Descent: f32,
    pub _bitfield_align_1: [u32; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
    pub LastUsedFrame: ::core::ffi::c_int,
    pub BakedId: ImGuiID,
    pub OwnerFont: *mut ImFont,
    pub FontLoaderDatas: *mut ::core::ffi::c_void,
}
impl ImFontBaked {
    #[inline]
    pub fn MetricsTotalSurface(&self) -> ::core::ffi::c_uint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 26u8) as u32) }
    }
    #[inline]
    pub fn set_MetricsTotalSurface(&mut self, val: ::core::ffi::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(0usize, 26u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn MetricsTotalSurface_raw(this: *const Self) -> ::core::ffi::c_uint {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                0usize,
                26u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_MetricsTotalSurface_raw(this: *mut Self, val: ::core::ffi::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                26u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn WantDestroy(&self) -> ::core::ffi::c_uint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_WantDestroy(&mut self, val: ::core::ffi::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(26usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn WantDestroy_raw(this: *const Self) -> ::core::ffi::c_uint {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                26usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_WantDestroy_raw(this: *mut Self, val: ::core::ffi::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                26usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn LoadNoFallback(&self) -> ::core::ffi::c_uint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_LoadNoFallback(&mut self, val: ::core::ffi::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(27usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn LoadNoFallback_raw(this: *const Self) -> ::core::ffi::c_uint {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                27usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_LoadNoFallback_raw(this: *mut Self, val: ::core::ffi::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                27usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn LoadNoRenderOnLayout(&self) -> ::core::ffi::c_uint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_LoadNoRenderOnLayout(&mut self, val: ::core::ffi::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(28usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn LoadNoRenderOnLayout_raw(this: *const Self) -> ::core::ffi::c_uint {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                28usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_LoadNoRenderOnLayout_raw(this: *mut Self, val: ::core::ffi::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                28usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        MetricsTotalSurface: ::core::ffi::c_uint,
        WantDestroy: ::core::ffi::c_uint,
        LoadNoFallback: ::core::ffi::c_uint,
        LoadNoRenderOnLayout: ::core::ffi::c_uint,
    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 26u8, {
            let MetricsTotalSurface: u32 = unsafe { ::core::mem::transmute(MetricsTotalSurface) };
            MetricsTotalSurface as u64
        });
        __bindgen_bitfield_unit.set(26usize, 1u8, {
            let WantDestroy: u32 = unsafe { ::core::mem::transmute(WantDestroy) };
            WantDestroy as u64
        });
        __bindgen_bitfield_unit.set(27usize, 1u8, {
            let LoadNoFallback: u32 = unsafe { ::core::mem::transmute(LoadNoFallback) };
            LoadNoFallback as u64
        });
        __bindgen_bitfield_unit.set(28usize, 1u8, {
            let LoadNoRenderOnLayout: u32 = unsafe { ::core::mem::transmute(LoadNoRenderOnLayout) };
            LoadNoRenderOnLayout as u64
        });
        __bindgen_bitfield_unit
    }
}
impl ImFontFlags {
    pub const None: ImFontFlags = ImFontFlags(0);
    pub const NoLoadError: ImFontFlags = ImFontFlags(2);
    pub const NoLoadGlyphs: ImFontFlags = ImFontFlags(4);
    pub const LockBakedSizes: ImFontFlags = ImFontFlags(8);
    pub const ImplicitRefSize: ImFontFlags = ImFontFlags(16);
}
impl ::core::ops::BitOr<ImFontFlags> for ImFontFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImFontFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImFontFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImFontFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImFontFlags> for ImFontFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImFontFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImFontFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImFontFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImFontFlags(pub ::core::ffi::c_uint);
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImFontConfigPtr {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut *mut ImFontConfig,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImFont {
    pub LastBaked: *mut ImFontBaked,
    pub OwnerAtlas: *mut ImFontAtlas,
    pub Flags: ImFontFlags,
    pub CurrentRasterizerDensity: f32,
    pub FontId: ImGuiID,
    pub LegacySize: f32,
    pub Sources: ImVector_ImFontConfigPtr,
    pub EllipsisChar: ImWchar,
    pub FallbackChar: ImWchar,
    pub Used8kPagesMap: [ImU8; 1usize],
    pub EllipsisAutoBake: bool,
    pub RemapPairs: ImGuiStorage,
}
impl ImGuiViewportFlags {
    pub const None: ImGuiViewportFlags = ImGuiViewportFlags(0);
    pub const IsPlatformWindow: ImGuiViewportFlags = ImGuiViewportFlags(1);
    pub const IsPlatformMonitor: ImGuiViewportFlags = ImGuiViewportFlags(2);
    pub const OwnedByApp: ImGuiViewportFlags = ImGuiViewportFlags(4);
}
impl ::core::ops::BitOr<ImGuiViewportFlags> for ImGuiViewportFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiViewportFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiViewportFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiViewportFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiViewportFlags> for ImGuiViewportFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiViewportFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiViewportFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiViewportFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiViewportFlags(pub ::core::ffi::c_uint);
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiViewport {
    pub ID: ImGuiID,
    pub Flags: ImGuiViewportFlags,
    pub Pos: ImVec2_c,
    pub Size: ImVec2_c,
    pub FramebufferScale: ImVec2_c,
    pub WorkPos: ImVec2_c,
    pub WorkSize: ImVec2_c,
    pub PlatformHandle: *mut ::core::ffi::c_void,
    pub PlatformHandleRaw: *mut ::core::ffi::c_void,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiPlatformIO {
    pub Platform_GetClipboardTextFn:
        ::core::option::Option<unsafe extern "C" fn(ctx: *mut ImGuiContext) -> *const ::core::ffi::c_char>,
    pub Platform_SetClipboardTextFn:
        ::core::option::Option<unsafe extern "C" fn(ctx: *mut ImGuiContext, text: *const ::core::ffi::c_char)>,
    pub Platform_ClipboardUserData: *mut ::core::ffi::c_void,
    pub Platform_OpenInShellFn:
        ::core::option::Option<unsafe extern "C" fn(ctx: *mut ImGuiContext, path: *const ::core::ffi::c_char) -> bool>,
    pub Platform_OpenInShellUserData: *mut ::core::ffi::c_void,
    pub Platform_SetImeDataFn: ::core::option::Option<
        unsafe extern "C" fn(ctx: *mut ImGuiContext, viewport: *mut ImGuiViewport, data: *mut ImGuiPlatformImeData),
    >,
    pub Platform_ImeUserData: *mut ::core::ffi::c_void,
    pub Platform_LocaleDecimalPoint: ImWchar,
    pub Renderer_TextureMaxWidth: ::core::ffi::c_int,
    pub Renderer_TextureMaxHeight: ::core::ffi::c_int,
    pub Renderer_RenderState: *mut ::core::ffi::c_void,
    pub DrawCallback_ResetRenderState: ImDrawCallback,
    pub DrawCallback_SetSamplerLinear: ImDrawCallback,
    pub DrawCallback_SetSamplerNearest: ImDrawCallback,
    pub Textures: ImVector_ImTextureDataPtr,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiPlatformImeData {
    pub WantVisible: bool,
    pub WantTextInput: bool,
    pub InputPos: ImVec2_c,
    pub InputLineHeight: f32,
    pub ViewportId: ImGuiID,
}
pub type ImGuiTableColumnIdx = ImS16;
pub type ImGuiTableDrawChannelIdx = ImU16;
impl ImDrawTextFlags {
    pub const None: ImDrawTextFlags = ImDrawTextFlags(0);
    pub const CpuFineClip: ImDrawTextFlags = ImDrawTextFlags(1);
    pub const WrapKeepBlanks: ImDrawTextFlags = ImDrawTextFlags(2);
    pub const StopOnNewLine: ImDrawTextFlags = ImDrawTextFlags(4);
}
impl ::core::ops::BitOr<ImDrawTextFlags> for ImDrawTextFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImDrawTextFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImDrawTextFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImDrawTextFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImDrawTextFlags> for ImDrawTextFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImDrawTextFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImDrawTextFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImDrawTextFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImDrawTextFlags(pub ::core::ffi::c_uint);
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ImWcharClass {
    Blank = 0,
    Punct = 1,
    Other = 2,
}
pub type ImFileHandle = *mut FILE;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVec1 {
    pub x: f32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVec2i_c {
    pub x: ::core::ffi::c_int,
    pub y: ::core::ffi::c_int,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVec2ih {
    pub x: ::core::ffi::c_short,
    pub y: ::core::ffi::c_short,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImRect_c {
    pub Min: ImVec2_c,
    pub Max: ImVec2_c,
}
pub type ImBitArrayPtr = *mut ImU32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImBitVector {
    pub Storage: ImVector_ImU32,
}
pub type ImPoolIdx = ::core::ffi::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_int {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ::core::ffi::c_int,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiTextIndex {
    pub Offsets: ImVector_int,
    pub EndOffset: ::core::ffi::c_int,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImDrawListSharedData {
    pub TexUvWhitePixel: ImVec2_c,
    pub TexUvLines: *const ImVec4_c,
    pub FontAtlas: *mut ImFontAtlas,
    pub Font: *mut ImFont,
    pub FontSize: f32,
    pub FontScale: f32,
    pub CurveTessellationTol: f32,
    pub CircleSegmentMaxError: f32,
    pub InitialFringeScale: f32,
    pub InitialFlags: ImDrawListFlags,
    pub ClipRectFullscreen: ImVec4_c,
    pub TempBuffer: ImVector_ImVec2,
    pub DrawLists: ImVector_ImDrawListPtr,
    pub Context: *mut ImGuiContext,
    pub ArcFastVtx: [ImVec2_c; 48usize],
    pub ArcFastRadiusCutoff: f32,
    pub CircleSegmentCounts: [ImU8; 64usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImDrawDataBuilder {
    pub Layers: [*mut ImVector_ImDrawListPtr; 2usize],
    pub LayerData1: ImVector_ImDrawListPtr,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImFontStackData {
    pub Font: *mut ImFont,
    pub FontSizeBeforeScaling: f32,
    pub FontSizeAfterScaling: f32,
}
#[repr(C)]
#[repr(align(4))]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiStyleVarInfo {
    pub _bitfield_align_1: [u16; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
}
impl ImGuiStyleVarInfo {
    #[inline]
    pub fn Count(&self) -> ImU32 {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_Count(&mut self, val: ImU32) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(0usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn Count_raw(this: *const Self) -> ImU32 {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                0usize,
                8u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_Count_raw(this: *mut Self, val: ImU32) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                8u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn DataType(&self) -> ImGuiDataType {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_DataType(&mut self, val: ImGuiDataType) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(8usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn DataType_raw(this: *const Self) -> ImGuiDataType {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                8usize,
                8u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_DataType_raw(this: *mut Self, val: ImGuiDataType) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                8usize,
                8u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn Offset(&self) -> ImU32 {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
    }
    #[inline]
    pub fn set_Offset(&mut self, val: ImU32) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(16usize, 16u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn Offset_raw(this: *const Self) -> ImU32 {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                16usize,
                16u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_Offset_raw(this: *mut Self, val: ImU32) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                16usize,
                16u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(Count: ImU32, DataType: ImGuiDataType, Offset: ImU32) -> __BindgenBitfieldUnit<[u8; 4usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 8u8, {
            let Count: u32 = unsafe { ::core::mem::transmute(Count) };
            Count as u64
        });
        __bindgen_bitfield_unit.set(8usize, 8u8, {
            let DataType: u32 = unsafe { ::core::mem::transmute(DataType) };
            DataType as u64
        });
        __bindgen_bitfield_unit.set(16usize, 16u8, {
            let Offset: u32 = unsafe { ::core::mem::transmute(Offset) };
            Offset as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiColorMod {
    pub Col: ImGuiCol,
    pub BackupValue: ImVec4_c,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ImGuiStyleMod {
    pub VarIdx: ImGuiStyleVar,
    pub __bindgen_anon_1: ImGuiStyleMod__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union ImGuiStyleMod__bindgen_ty_1 {
    pub BackupInt: [::core::ffi::c_int; 2usize],
    pub BackupFloat: [f32; 2usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiDataTypeStorage {
    pub Data: [ImU8; 8usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiDataTypeInfo {
    pub Size: usize,
    pub Name: *const ::core::ffi::c_char,
    pub PrintFmt: *const ::core::ffi::c_char,
    pub ScanFmt: *const ::core::ffi::c_char,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ImGuiDataTypePrivate {
    ImGuiDataType_Pointer = 12,
    ImGuiDataType_ID = 13,
}
impl ImGuiItemFlagsPrivate {
    pub const ImGuiItemFlags_ReadOnly: ImGuiItemFlagsPrivate = ImGuiItemFlagsPrivate(2048);
    pub const ImGuiItemFlags_MixedValue: ImGuiItemFlagsPrivate = ImGuiItemFlagsPrivate(4096);
    pub const ImGuiItemFlags_NoWindowHoverableCheck: ImGuiItemFlagsPrivate = ImGuiItemFlagsPrivate(8192);
    pub const ImGuiItemFlags_AllowOverlap: ImGuiItemFlagsPrivate = ImGuiItemFlagsPrivate(16384);
    pub const ImGuiItemFlags_NoNavDisableMouseHover: ImGuiItemFlagsPrivate = ImGuiItemFlagsPrivate(32768);
    pub const ImGuiItemFlags_NoMarkEdited: ImGuiItemFlagsPrivate = ImGuiItemFlagsPrivate(65536);
    pub const ImGuiItemFlags_NoFocus: ImGuiItemFlagsPrivate = ImGuiItemFlagsPrivate(131072);
    pub const ImGuiItemFlags_Inputable: ImGuiItemFlagsPrivate = ImGuiItemFlagsPrivate(1048576);
    pub const ImGuiItemFlags_HasSelectionUserData: ImGuiItemFlagsPrivate = ImGuiItemFlagsPrivate(2097152);
    pub const ImGuiItemFlags_IsMultiSelect: ImGuiItemFlagsPrivate = ImGuiItemFlagsPrivate(4194304);
    pub const ImGuiItemFlags_Default_: ImGuiItemFlagsPrivate = ImGuiItemFlagsPrivate(16);
}
impl ::core::ops::BitOr<ImGuiItemFlagsPrivate> for ImGuiItemFlagsPrivate {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiItemFlagsPrivate(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiItemFlagsPrivate {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiItemFlagsPrivate) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiItemFlagsPrivate> for ImGuiItemFlagsPrivate {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiItemFlagsPrivate(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiItemFlagsPrivate {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiItemFlagsPrivate) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiItemFlagsPrivate(pub ::core::ffi::c_uint);
impl ImGuiItemStatusFlags {
    pub const None: ImGuiItemStatusFlags = ImGuiItemStatusFlags(0);
    pub const HoveredRect: ImGuiItemStatusFlags = ImGuiItemStatusFlags(1);
    pub const HasDisplayRect: ImGuiItemStatusFlags = ImGuiItemStatusFlags(2);
    pub const Edited: ImGuiItemStatusFlags = ImGuiItemStatusFlags(4);
    pub const ToggledSelection: ImGuiItemStatusFlags = ImGuiItemStatusFlags(8);
    pub const ToggledOpen: ImGuiItemStatusFlags = ImGuiItemStatusFlags(16);
    pub const HasDeactivated: ImGuiItemStatusFlags = ImGuiItemStatusFlags(32);
    pub const Deactivated: ImGuiItemStatusFlags = ImGuiItemStatusFlags(64);
    pub const HoveredWindow: ImGuiItemStatusFlags = ImGuiItemStatusFlags(128);
    pub const Visible: ImGuiItemStatusFlags = ImGuiItemStatusFlags(256);
    pub const HasClipRect: ImGuiItemStatusFlags = ImGuiItemStatusFlags(512);
    pub const HasShortcut: ImGuiItemStatusFlags = ImGuiItemStatusFlags(1024);
    pub const EditedInternal: ImGuiItemStatusFlags = ImGuiItemStatusFlags(2048);
}
impl ::core::ops::BitOr<ImGuiItemStatusFlags> for ImGuiItemStatusFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiItemStatusFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiItemStatusFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiItemStatusFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiItemStatusFlags> for ImGuiItemStatusFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiItemStatusFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiItemStatusFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiItemStatusFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiItemStatusFlags(pub ::core::ffi::c_uint);
impl ImGuiHoveredFlagsPrivate {
    pub const ImGuiHoveredFlags_DelayMask_: ImGuiHoveredFlagsPrivate = ImGuiHoveredFlagsPrivate(245760);
    pub const ImGuiHoveredFlags_AllowedMaskForIsWindowHovered: ImGuiHoveredFlagsPrivate = ImGuiHoveredFlagsPrivate(12463);
    pub const ImGuiHoveredFlags_AllowedMaskForIsItemHovered: ImGuiHoveredFlagsPrivate = ImGuiHoveredFlagsPrivate(262048);
}
impl ::core::ops::BitOr<ImGuiHoveredFlagsPrivate> for ImGuiHoveredFlagsPrivate {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiHoveredFlagsPrivate(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiHoveredFlagsPrivate {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiHoveredFlagsPrivate) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiHoveredFlagsPrivate> for ImGuiHoveredFlagsPrivate {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiHoveredFlagsPrivate(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiHoveredFlagsPrivate {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiHoveredFlagsPrivate) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiHoveredFlagsPrivate(pub ::core::ffi::c_uint);
impl ImGuiInputTextFlagsPrivate {
    pub const ImGuiInputTextFlags_Multiline: ImGuiInputTextFlagsPrivate = ImGuiInputTextFlagsPrivate(67108864);
    pub const ImGuiInputTextFlags_TempInput: ImGuiInputTextFlagsPrivate = ImGuiInputTextFlagsPrivate(134217728);
    pub const ImGuiInputTextFlags_LocalizeDecimalPoint: ImGuiInputTextFlagsPrivate = ImGuiInputTextFlagsPrivate(268435456);
}
impl ::core::ops::BitOr<ImGuiInputTextFlagsPrivate> for ImGuiInputTextFlagsPrivate {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiInputTextFlagsPrivate(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiInputTextFlagsPrivate {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiInputTextFlagsPrivate) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiInputTextFlagsPrivate> for ImGuiInputTextFlagsPrivate {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiInputTextFlagsPrivate(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiInputTextFlagsPrivate {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiInputTextFlagsPrivate) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiInputTextFlagsPrivate(pub ::core::ffi::c_uint);
impl ImGuiButtonFlagsPrivate {
    pub const ImGuiButtonFlags_PressedOnClick: ImGuiButtonFlagsPrivate = ImGuiButtonFlagsPrivate(16);
    pub const ImGuiButtonFlags_PressedOnClickRelease: ImGuiButtonFlagsPrivate = ImGuiButtonFlagsPrivate(32);
    pub const ImGuiButtonFlags_PressedOnClickReleaseAnywhere: ImGuiButtonFlagsPrivate = ImGuiButtonFlagsPrivate(64);
    pub const ImGuiButtonFlags_PressedOnRelease: ImGuiButtonFlagsPrivate = ImGuiButtonFlagsPrivate(128);
    pub const ImGuiButtonFlags_PressedOnDoubleClick: ImGuiButtonFlagsPrivate = ImGuiButtonFlagsPrivate(256);
    pub const ImGuiButtonFlags_PressedOnDragDropHold: ImGuiButtonFlagsPrivate = ImGuiButtonFlagsPrivate(512);
    pub const ImGuiButtonFlags_FlattenChildren: ImGuiButtonFlagsPrivate = ImGuiButtonFlagsPrivate(2048);
    pub const ImGuiButtonFlags_AlignTextBaseLine: ImGuiButtonFlagsPrivate = ImGuiButtonFlagsPrivate(32768);
    pub const ImGuiButtonFlags_NoKeyModsAllowed: ImGuiButtonFlagsPrivate = ImGuiButtonFlagsPrivate(65536);
    pub const ImGuiButtonFlags_NoHoldingActiveId: ImGuiButtonFlagsPrivate = ImGuiButtonFlagsPrivate(131072);
    pub const ImGuiButtonFlags_NoNavFocus: ImGuiButtonFlagsPrivate = ImGuiButtonFlagsPrivate(262144);
    pub const ImGuiButtonFlags_NoHoveredOnFocus: ImGuiButtonFlagsPrivate = ImGuiButtonFlagsPrivate(524288);
    pub const ImGuiButtonFlags_NoSetKeyOwner: ImGuiButtonFlagsPrivate = ImGuiButtonFlagsPrivate(1048576);
    pub const ImGuiButtonFlags_NoTestKeyOwner: ImGuiButtonFlagsPrivate = ImGuiButtonFlagsPrivate(2097152);
    pub const ImGuiButtonFlags_NoFocus: ImGuiButtonFlagsPrivate = ImGuiButtonFlagsPrivate(4194304);
    pub const ImGuiButtonFlags_PressedOnMask_: ImGuiButtonFlagsPrivate = ImGuiButtonFlagsPrivate(1008);
    pub const ImGuiButtonFlags_PressedOnDefault_: ImGuiButtonFlagsPrivate = ImGuiButtonFlagsPrivate(32);
}
impl ::core::ops::BitOr<ImGuiButtonFlagsPrivate> for ImGuiButtonFlagsPrivate {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiButtonFlagsPrivate(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiButtonFlagsPrivate {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiButtonFlagsPrivate) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiButtonFlagsPrivate> for ImGuiButtonFlagsPrivate {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiButtonFlagsPrivate(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiButtonFlagsPrivate {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiButtonFlagsPrivate) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiButtonFlagsPrivate(pub ::core::ffi::c_uint);
impl ImGuiComboFlagsPrivate {
    pub const ImGuiComboFlags_CustomPreview: ImGuiComboFlagsPrivate = ImGuiComboFlagsPrivate(1048576);
}
impl ::core::ops::BitOr<ImGuiComboFlagsPrivate> for ImGuiComboFlagsPrivate {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiComboFlagsPrivate(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiComboFlagsPrivate {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiComboFlagsPrivate) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiComboFlagsPrivate> for ImGuiComboFlagsPrivate {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiComboFlagsPrivate(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiComboFlagsPrivate {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiComboFlagsPrivate) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiComboFlagsPrivate(pub ::core::ffi::c_uint);
impl ImGuiSliderFlagsPrivate {
    pub const ImGuiSliderFlags_Vertical: ImGuiSliderFlagsPrivate = ImGuiSliderFlagsPrivate(1048576);
    pub const ImGuiSliderFlags_ReadOnly: ImGuiSliderFlagsPrivate = ImGuiSliderFlagsPrivate(2097152);
}
impl ::core::ops::BitOr<ImGuiSliderFlagsPrivate> for ImGuiSliderFlagsPrivate {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiSliderFlagsPrivate(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiSliderFlagsPrivate {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiSliderFlagsPrivate) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiSliderFlagsPrivate> for ImGuiSliderFlagsPrivate {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiSliderFlagsPrivate(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiSliderFlagsPrivate {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiSliderFlagsPrivate) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiSliderFlagsPrivate(pub ::core::ffi::c_uint);
impl ImGuiSelectableFlagsPrivate {
    pub const ImGuiSelectableFlags_NoHoldingActiveID: ImGuiSelectableFlagsPrivate = ImGuiSelectableFlagsPrivate(1048576);
    pub const ImGuiSelectableFlags_SelectOnClick: ImGuiSelectableFlagsPrivate = ImGuiSelectableFlagsPrivate(4194304);
    pub const ImGuiSelectableFlags_SelectOnRelease: ImGuiSelectableFlagsPrivate = ImGuiSelectableFlagsPrivate(8388608);
    pub const ImGuiSelectableFlags_SpanAvailWidth: ImGuiSelectableFlagsPrivate = ImGuiSelectableFlagsPrivate(16777216);
    pub const ImGuiSelectableFlags_SetNavIdOnHover: ImGuiSelectableFlagsPrivate = ImGuiSelectableFlagsPrivate(33554432);
    pub const ImGuiSelectableFlags_NoPadWithHalfSpacing: ImGuiSelectableFlagsPrivate = ImGuiSelectableFlagsPrivate(67108864);
    pub const ImGuiSelectableFlags_NoSetKeyOwner: ImGuiSelectableFlagsPrivate = ImGuiSelectableFlagsPrivate(134217728);
}
impl ::core::ops::BitOr<ImGuiSelectableFlagsPrivate> for ImGuiSelectableFlagsPrivate {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiSelectableFlagsPrivate(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiSelectableFlagsPrivate {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiSelectableFlagsPrivate) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiSelectableFlagsPrivate> for ImGuiSelectableFlagsPrivate {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiSelectableFlagsPrivate(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiSelectableFlagsPrivate {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiSelectableFlagsPrivate) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiSelectableFlagsPrivate(pub ::core::ffi::c_uint);
impl ImGuiTreeNodeFlagsPrivate {
    pub const ImGuiTreeNodeFlags_NoNavFocus: ImGuiTreeNodeFlagsPrivate = ImGuiTreeNodeFlagsPrivate(134217728);
    pub const ImGuiTreeNodeFlags_ClipLabelForTrailingButton: ImGuiTreeNodeFlagsPrivate = ImGuiTreeNodeFlagsPrivate(268435456);
    pub const ImGuiTreeNodeFlags_UpsideDownArrow: ImGuiTreeNodeFlagsPrivate = ImGuiTreeNodeFlagsPrivate(536870912);
    pub const ImGuiTreeNodeFlags_OpenOnMask_: ImGuiTreeNodeFlagsPrivate = ImGuiTreeNodeFlagsPrivate(192);
    pub const ImGuiTreeNodeFlags_DrawLinesMask_: ImGuiTreeNodeFlagsPrivate = ImGuiTreeNodeFlagsPrivate(1835008);
}
impl ::core::ops::BitOr<ImGuiTreeNodeFlagsPrivate> for ImGuiTreeNodeFlagsPrivate {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiTreeNodeFlagsPrivate(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiTreeNodeFlagsPrivate {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiTreeNodeFlagsPrivate) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiTreeNodeFlagsPrivate> for ImGuiTreeNodeFlagsPrivate {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiTreeNodeFlagsPrivate(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiTreeNodeFlagsPrivate {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiTreeNodeFlagsPrivate) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiTreeNodeFlagsPrivate(pub ::core::ffi::c_uint);
impl ImGuiSeparatorFlags {
    pub const None: ImGuiSeparatorFlags = ImGuiSeparatorFlags(0);
    pub const Horizontal: ImGuiSeparatorFlags = ImGuiSeparatorFlags(1);
    pub const Vertical: ImGuiSeparatorFlags = ImGuiSeparatorFlags(2);
    pub const SpanAllColumns: ImGuiSeparatorFlags = ImGuiSeparatorFlags(4);
}
impl ::core::ops::BitOr<ImGuiSeparatorFlags> for ImGuiSeparatorFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiSeparatorFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiSeparatorFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiSeparatorFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiSeparatorFlags> for ImGuiSeparatorFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiSeparatorFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiSeparatorFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiSeparatorFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiSeparatorFlags(pub ::core::ffi::c_uint);
impl ImGuiFocusRequestFlags {
    pub const None: ImGuiFocusRequestFlags = ImGuiFocusRequestFlags(0);
    pub const RestoreFocusedChild: ImGuiFocusRequestFlags = ImGuiFocusRequestFlags(1);
    pub const UnlessBelowModal: ImGuiFocusRequestFlags = ImGuiFocusRequestFlags(2);
}
impl ::core::ops::BitOr<ImGuiFocusRequestFlags> for ImGuiFocusRequestFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiFocusRequestFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiFocusRequestFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiFocusRequestFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiFocusRequestFlags> for ImGuiFocusRequestFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiFocusRequestFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiFocusRequestFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiFocusRequestFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiFocusRequestFlags(pub ::core::ffi::c_uint);
impl ImGuiTextFlags {
    pub const None: ImGuiTextFlags = ImGuiTextFlags(0);
    pub const NoWidthForLargeClippedText: ImGuiTextFlags = ImGuiTextFlags(1);
}
impl ::core::ops::BitOr<ImGuiTextFlags> for ImGuiTextFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiTextFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiTextFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiTextFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiTextFlags> for ImGuiTextFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiTextFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiTextFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiTextFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiTextFlags(pub ::core::ffi::c_uint);
impl ImGuiTooltipFlags {
    pub const None: ImGuiTooltipFlags = ImGuiTooltipFlags(0);
    pub const OverridePrevious: ImGuiTooltipFlags = ImGuiTooltipFlags(2);
}
impl ::core::ops::BitOr<ImGuiTooltipFlags> for ImGuiTooltipFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiTooltipFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiTooltipFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiTooltipFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiTooltipFlags> for ImGuiTooltipFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiTooltipFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiTooltipFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiTooltipFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiTooltipFlags(pub ::core::ffi::c_uint);
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ImGuiLayoutType {
    Horizontal = 0,
    Vertical = 1,
}
impl ImGuiLogFlags {
    pub const None: ImGuiLogFlags = ImGuiLogFlags(0);
    pub const OutputTTY: ImGuiLogFlags = ImGuiLogFlags(1);
    pub const OutputFile: ImGuiLogFlags = ImGuiLogFlags(2);
    pub const OutputBuffer: ImGuiLogFlags = ImGuiLogFlags(4);
    pub const OutputClipboard: ImGuiLogFlags = ImGuiLogFlags(8);
    pub const OutputMask_: ImGuiLogFlags = ImGuiLogFlags(15);
}
impl ::core::ops::BitOr<ImGuiLogFlags> for ImGuiLogFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiLogFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiLogFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiLogFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiLogFlags> for ImGuiLogFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiLogFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiLogFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiLogFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiLogFlags(pub ::core::ffi::c_uint);
#[repr(i32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ImGuiAxis {
    None = -1,
    X = 0,
    Y = 1,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ImGuiPlotType {
    Lines = 0,
    Histogram = 1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiComboPreviewData {
    pub PreviewRect: ImRect_c,
    pub BackupCursorPos: ImVec2_c,
    pub BackupCursorMaxPos: ImVec2_c,
    pub BackupCursorPosPrevLine: ImVec2_c,
    pub BackupPrevLineTextBaseOffset: f32,
    pub BackupLayout: ImGuiLayoutType,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiGroupData {
    pub WindowID: ImGuiID,
    pub BackupCursorPos: ImVec2_c,
    pub BackupCursorMaxPos: ImVec2_c,
    pub BackupCursorPosPrevLine: ImVec2_c,
    pub BackupIndent: ImVec1,
    pub BackupGroupOffset: ImVec1,
    pub BackupCurrLineSize: ImVec2_c,
    pub BackupCurrLineTextBaseOffset: f32,
    pub BackupActiveIdIsAlive: ImGuiID,
    pub BackupActiveIdHasBeenEditedThisFrame: bool,
    pub BackupDeactivatedIdIsAlive: bool,
    pub BackupHoveredIdIsAlive: bool,
    pub BackupIsSameLine: bool,
    pub EmitItem: bool,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiMenuColumns {
    pub TotalWidth: ImU32,
    pub NextTotalWidth: ImU32,
    pub Spacing: ImU16,
    pub OffsetIcon: ImU16,
    pub OffsetLabel: ImU16,
    pub OffsetShortcut: ImU16,
    pub OffsetMark: ImU16,
    pub Widths: [ImU16; 4usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiInputTextDeactivatedState {
    pub ID: ImGuiID,
    pub TextA: ImVector_char,
}
pub type ImStbTexteditState = STB_TexteditState;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiInputTextState {
    pub Ctx: *mut ImGuiContext,
    pub Stb: *mut ImStbTexteditState,
    pub Flags: ImGuiInputTextFlags,
    pub ID: ImGuiID,
    pub TextLen: ::core::ffi::c_int,
    pub TextSrc: *const ::core::ffi::c_char,
    pub TextA: ImVector_char,
    pub TextToRevertTo: ImVector_char,
    pub CallbackTextBackup: ImVector_char,
    pub BufCapacity: ::core::ffi::c_int,
    pub Scroll: ImVec2_c,
    pub LineCount: ::core::ffi::c_int,
    pub WrapWidth: f32,
    pub CursorAnim: f32,
    pub CursorFollow: bool,
    pub CursorCenterY: bool,
    pub SelectedAllMouseLock: bool,
    pub EditedBefore: bool,
    pub EditedThisFrame: bool,
    pub WantReloadUserBuf: bool,
    pub LastMoveDirectionLR: ImS8,
    pub ReloadSelectionStart: ::core::ffi::c_int,
    pub ReloadSelectionEnd: ::core::ffi::c_int,
}
impl ImGuiWindowRefreshFlags {
    pub const None: ImGuiWindowRefreshFlags = ImGuiWindowRefreshFlags(0);
    pub const TryToAvoidRefresh: ImGuiWindowRefreshFlags = ImGuiWindowRefreshFlags(1);
    pub const RefreshOnHover: ImGuiWindowRefreshFlags = ImGuiWindowRefreshFlags(2);
    pub const RefreshOnFocus: ImGuiWindowRefreshFlags = ImGuiWindowRefreshFlags(4);
}
impl ::core::ops::BitOr<ImGuiWindowRefreshFlags> for ImGuiWindowRefreshFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiWindowRefreshFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiWindowRefreshFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiWindowRefreshFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiWindowRefreshFlags> for ImGuiWindowRefreshFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiWindowRefreshFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiWindowRefreshFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiWindowRefreshFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiWindowRefreshFlags(pub ::core::ffi::c_uint);
impl ImGuiWindowBgClickFlags {
    pub const None: ImGuiWindowBgClickFlags = ImGuiWindowBgClickFlags(0);
    pub const Move: ImGuiWindowBgClickFlags = ImGuiWindowBgClickFlags(1);
}
impl ::core::ops::BitOr<ImGuiWindowBgClickFlags> for ImGuiWindowBgClickFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiWindowBgClickFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiWindowBgClickFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiWindowBgClickFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiWindowBgClickFlags> for ImGuiWindowBgClickFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiWindowBgClickFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiWindowBgClickFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiWindowBgClickFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiWindowBgClickFlags(pub ::core::ffi::c_uint);
impl ImGuiNextWindowDataFlags {
    pub const None: ImGuiNextWindowDataFlags = ImGuiNextWindowDataFlags(0);
    pub const HasPos: ImGuiNextWindowDataFlags = ImGuiNextWindowDataFlags(1);
    pub const HasSize: ImGuiNextWindowDataFlags = ImGuiNextWindowDataFlags(2);
    pub const HasContentSize: ImGuiNextWindowDataFlags = ImGuiNextWindowDataFlags(4);
    pub const HasCollapsed: ImGuiNextWindowDataFlags = ImGuiNextWindowDataFlags(8);
    pub const HasSizeConstraint: ImGuiNextWindowDataFlags = ImGuiNextWindowDataFlags(16);
    pub const HasFocus: ImGuiNextWindowDataFlags = ImGuiNextWindowDataFlags(32);
    pub const HasBgAlpha: ImGuiNextWindowDataFlags = ImGuiNextWindowDataFlags(64);
    pub const HasScroll: ImGuiNextWindowDataFlags = ImGuiNextWindowDataFlags(128);
    pub const HasWindowFlags: ImGuiNextWindowDataFlags = ImGuiNextWindowDataFlags(256);
    pub const HasChildFlags: ImGuiNextWindowDataFlags = ImGuiNextWindowDataFlags(512);
    pub const HasRefreshPolicy: ImGuiNextWindowDataFlags = ImGuiNextWindowDataFlags(1024);
}
impl ::core::ops::BitOr<ImGuiNextWindowDataFlags> for ImGuiNextWindowDataFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiNextWindowDataFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiNextWindowDataFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiNextWindowDataFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiNextWindowDataFlags> for ImGuiNextWindowDataFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiNextWindowDataFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiNextWindowDataFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiNextWindowDataFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiNextWindowDataFlags(pub ::core::ffi::c_uint);
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiNextWindowData {
    pub HasFlags: ImGuiNextWindowDataFlags,
    pub PosCond: ImGuiCond,
    pub SizeCond: ImGuiCond,
    pub CollapsedCond: ImGuiCond,
    pub PosVal: ImVec2_c,
    pub PosPivotVal: ImVec2_c,
    pub SizeVal: ImVec2_c,
    pub ContentSizeVal: ImVec2_c,
    pub ScrollVal: ImVec2_c,
    pub WindowFlags: ImGuiWindowFlags,
    pub ChildFlags: ImGuiChildFlags,
    pub CollapsedVal: bool,
    pub SizeConstraintRect: ImRect_c,
    pub SizeCallback: ImGuiSizeCallback,
    pub SizeCallbackUserData: *mut ::core::ffi::c_void,
    pub BgAlphaVal: f32,
    pub MenuBarOffsetMinVal: ImVec2_c,
    pub RefreshFlagsVal: ImGuiWindowRefreshFlags,
}
impl ImGuiNextItemDataFlags {
    pub const None: ImGuiNextItemDataFlags = ImGuiNextItemDataFlags(0);
    pub const HasWidth: ImGuiNextItemDataFlags = ImGuiNextItemDataFlags(1);
    pub const HasOpen: ImGuiNextItemDataFlags = ImGuiNextItemDataFlags(2);
    pub const HasShortcut: ImGuiNextItemDataFlags = ImGuiNextItemDataFlags(4);
    pub const HasRefVal: ImGuiNextItemDataFlags = ImGuiNextItemDataFlags(8);
    pub const HasStorageID: ImGuiNextItemDataFlags = ImGuiNextItemDataFlags(16);
    pub const HasColorMarker: ImGuiNextItemDataFlags = ImGuiNextItemDataFlags(32);
}
impl ::core::ops::BitOr<ImGuiNextItemDataFlags> for ImGuiNextItemDataFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiNextItemDataFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiNextItemDataFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiNextItemDataFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiNextItemDataFlags> for ImGuiNextItemDataFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiNextItemDataFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiNextItemDataFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiNextItemDataFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiNextItemDataFlags(pub ::core::ffi::c_uint);
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiNextItemData {
    pub HasFlags: ImGuiNextItemDataFlags,
    pub ItemFlags: ImGuiItemFlags,
    pub FocusScopeId: ImGuiID,
    pub SelectionUserData: ImGuiSelectionUserData,
    pub Width: f32,
    pub Shortcut: ImGuiKeyChord,
    pub ShortcutFlags: ImGuiInputFlags,
    pub OpenVal: bool,
    pub OpenCond: ImU8,
    pub RefVal: ImGuiDataTypeStorage,
    pub StorageId: ImGuiID,
    pub ColorMarker: ImU32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiLastItemData {
    pub ID: ImGuiID,
    pub ItemFlags: ImGuiItemFlags,
    pub StatusFlags: ImGuiItemStatusFlags,
    pub Rect: ImRect_c,
    pub NavRect: ImRect_c,
    pub DisplayRect: ImRect_c,
    pub ClipRect: ImRect_c,
    pub Shortcut: ImGuiKeyChord,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiTreeNodeStackData {
    pub ID: ImGuiID,
    pub TreeFlags: ImGuiTreeNodeFlags,
    pub ItemFlags: ImGuiItemFlags,
    pub NavRect: ImRect_c,
    pub DrawLinesX1: f32,
    pub DrawLinesToNodesY2: f32,
    pub DrawLinesTableColumn: ImGuiTableColumnIdx,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiErrorRecoveryState {
    pub SizeOfWindowStack: ::core::ffi::c_short,
    pub SizeOfIDStack: ::core::ffi::c_short,
    pub SizeOfTreeStack: ::core::ffi::c_short,
    pub SizeOfColorStack: ::core::ffi::c_short,
    pub SizeOfStyleVarStack: ::core::ffi::c_short,
    pub SizeOfFontStack: ::core::ffi::c_short,
    pub SizeOfFocusScopeStack: ::core::ffi::c_short,
    pub SizeOfGroupStack: ::core::ffi::c_short,
    pub SizeOfItemFlagsStack: ::core::ffi::c_short,
    pub SizeOfBeginPopupStack: ::core::ffi::c_short,
    pub SizeOfDisabledStack: ::core::ffi::c_short,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiWindowStackData {
    pub Window: *mut ImGuiWindow,
    pub ParentLastItemDataBackup: ImGuiLastItemData,
    pub StackSizesInBegin: ImGuiErrorRecoveryState,
    pub DisabledOverrideReenable: bool,
    pub DisabledOverrideReenableAlphaBackup: f32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiShrinkWidthItem {
    pub Index: ::core::ffi::c_int,
    pub Width: f32,
    pub InitialWidth: f32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiPtrOrIndex {
    pub Ptr: *mut ::core::ffi::c_void,
    pub Index: ::core::ffi::c_int,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiDeactivatedItemData {
    pub ID: ImGuiID,
    pub ElapseFrame: ::core::ffi::c_int,
    pub HasBeenEditedBefore: bool,
    pub IsAlive: bool,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ImGuiPopupPositionPolicy {
    Default = 0,
    ComboBox = 1,
    Tooltip = 2,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiPopupData {
    pub PopupId: ImGuiID,
    pub Window: *mut ImGuiWindow,
    pub RestoreNavWindow: *mut ImGuiWindow,
    pub ParentNavLayer: ::core::ffi::c_int,
    pub OpenFrameCount: ::core::ffi::c_int,
    pub OpenParentId: ImGuiID,
    pub OpenPopupPos: ImVec2_c,
    pub OpenMousePos: ImVec2_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImBitArray_ImGuiKey_NamedKey_COUNT__lessImGuiKey_NamedKey_BEGIN {
    pub Data: [ImU32; 5usize],
}
pub type ImBitArrayForNamedKeys = ImBitArray_ImGuiKey_NamedKey_COUNT__lessImGuiKey_NamedKey_BEGIN;
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ImGuiInputEventType {
    None = 0,
    MousePos = 1,
    MouseWheel = 2,
    MouseButton = 3,
    Key = 4,
    Text = 5,
    Focus = 6,
    COUNT = 7,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ImGuiInputSource {
    None = 0,
    Mouse = 1,
    Keyboard = 2,
    Gamepad = 3,
    COUNT = 4,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiInputEventMousePos {
    pub PosX: f32,
    pub PosY: f32,
    pub MouseSource: ImGuiMouseSource,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiInputEventMouseWheel {
    pub WheelX: f32,
    pub WheelY: f32,
    pub MouseSource: ImGuiMouseSource,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiInputEventMouseButton {
    pub Button: ::core::ffi::c_int,
    pub Down: bool,
    pub MouseSource: ImGuiMouseSource,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiInputEventKey {
    pub Key: ImGuiKey,
    pub Down: bool,
    pub AnalogValue: f32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiInputEventText {
    pub Char: ::core::ffi::c_uint,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiInputEventAppFocused {
    pub Focused: bool,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ImGuiInputEvent {
    pub Type: ImGuiInputEventType,
    pub Source: ImGuiInputSource,
    pub EventId: ImU32,
    pub __bindgen_anon_1: ImGuiInputEvent__bindgen_ty_1,
    pub AddedByTestEngine: bool,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union ImGuiInputEvent__bindgen_ty_1 {
    pub MousePos: ImGuiInputEventMousePos,
    pub MouseWheel: ImGuiInputEventMouseWheel,
    pub MouseButton: ImGuiInputEventMouseButton,
    pub Key: ImGuiInputEventKey,
    pub Text: ImGuiInputEventText,
    pub AppFocused: ImGuiInputEventAppFocused,
}
pub type ImGuiKeyRoutingIndex = ImS16;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiKeyRoutingData {
    pub NextEntryIndex: ImGuiKeyRoutingIndex,
    pub Mods: ImU16,
    pub RoutingCurrScore: ImU16,
    pub RoutingNextScore: ImU16,
    pub RoutingCurr: ImGuiID,
    pub RoutingNext: ImGuiID,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiKeyRoutingData {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiKeyRoutingData,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiKeyRoutingTable {
    pub Index: [ImGuiKeyRoutingIndex; 155usize],
    pub Entries: ImVector_ImGuiKeyRoutingData,
    pub EntriesNext: ImVector_ImGuiKeyRoutingData,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiKeyOwnerData {
    pub OwnerCurr: ImGuiID,
    pub OwnerNext: ImGuiID,
    pub LockThisFrame: bool,
    pub LockUntilRelease: bool,
}
impl ImGuiInputFlagsPrivate {
    pub const ImGuiInputFlags_RepeatRateDefault: ImGuiInputFlagsPrivate = ImGuiInputFlagsPrivate(2);
    pub const ImGuiInputFlags_RepeatRateNavMove: ImGuiInputFlagsPrivate = ImGuiInputFlagsPrivate(4);
    pub const ImGuiInputFlags_RepeatRateNavTweak: ImGuiInputFlagsPrivate = ImGuiInputFlagsPrivate(8);
    pub const ImGuiInputFlags_RepeatUntilRelease: ImGuiInputFlagsPrivate = ImGuiInputFlagsPrivate(16);
    pub const ImGuiInputFlags_RepeatUntilKeyModsChange: ImGuiInputFlagsPrivate = ImGuiInputFlagsPrivate(32);
    pub const ImGuiInputFlags_RepeatUntilKeyModsChangeFromNone: ImGuiInputFlagsPrivate = ImGuiInputFlagsPrivate(64);
    pub const ImGuiInputFlags_RepeatUntilOtherKeyPress: ImGuiInputFlagsPrivate = ImGuiInputFlagsPrivate(128);
    pub const ImGuiInputFlags_LockThisFrame: ImGuiInputFlagsPrivate = ImGuiInputFlagsPrivate(1048576);
    pub const ImGuiInputFlags_LockUntilRelease: ImGuiInputFlagsPrivate = ImGuiInputFlagsPrivate(2097152);
    pub const ImGuiInputFlags_CondHovered: ImGuiInputFlagsPrivate = ImGuiInputFlagsPrivate(4194304);
    pub const ImGuiInputFlags_CondActive: ImGuiInputFlagsPrivate = ImGuiInputFlagsPrivate(8388608);
    pub const ImGuiInputFlags_CondDefault_: ImGuiInputFlagsPrivate = ImGuiInputFlagsPrivate(12582912);
    pub const ImGuiInputFlags_RepeatRateMask_: ImGuiInputFlagsPrivate = ImGuiInputFlagsPrivate(14);
    pub const ImGuiInputFlags_RepeatUntilMask_: ImGuiInputFlagsPrivate = ImGuiInputFlagsPrivate(240);
    pub const ImGuiInputFlags_RepeatMask_: ImGuiInputFlagsPrivate = ImGuiInputFlagsPrivate(255);
    pub const ImGuiInputFlags_CondMask_: ImGuiInputFlagsPrivate = ImGuiInputFlagsPrivate(12582912);
    pub const ImGuiInputFlags_RouteTypeMask_: ImGuiInputFlagsPrivate = ImGuiInputFlagsPrivate(15360);
    pub const ImGuiInputFlags_RouteOptionsMask_: ImGuiInputFlagsPrivate = ImGuiInputFlagsPrivate(245760);
    pub const ImGuiInputFlags_SupportedByIsKeyPressed: ImGuiInputFlagsPrivate = ImGuiInputFlagsPrivate(255);
    pub const ImGuiInputFlags_SupportedByIsMouseClicked: ImGuiInputFlagsPrivate = ImGuiInputFlagsPrivate(1);
    pub const ImGuiInputFlags_SupportedByShortcut: ImGuiInputFlagsPrivate = ImGuiInputFlagsPrivate(261375);
    pub const ImGuiInputFlags_SupportedBySetNextItemShortcut: ImGuiInputFlagsPrivate = ImGuiInputFlagsPrivate(523519);
    pub const ImGuiInputFlags_SupportedBySetKeyOwner: ImGuiInputFlagsPrivate = ImGuiInputFlagsPrivate(3145728);
    pub const ImGuiInputFlags_SupportedBySetItemKeyOwner: ImGuiInputFlagsPrivate = ImGuiInputFlagsPrivate(15728640);
}
impl ::core::ops::BitOr<ImGuiInputFlagsPrivate> for ImGuiInputFlagsPrivate {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiInputFlagsPrivate(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiInputFlagsPrivate {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiInputFlagsPrivate) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiInputFlagsPrivate> for ImGuiInputFlagsPrivate {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiInputFlagsPrivate(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiInputFlagsPrivate {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiInputFlagsPrivate) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiInputFlagsPrivate(pub ::core::ffi::c_uint);
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiListClipperRange {
    pub Min: ::core::ffi::c_int,
    pub Max: ::core::ffi::c_int,
    pub PosToIndexConvert: bool,
    pub PosToIndexOffsetMin: ImS8,
    pub PosToIndexOffsetMax: ImS8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiListClipperRange {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiListClipperRange,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiListClipperData {
    pub ListClipper: *mut ImGuiListClipper,
    pub LossynessOffset: f32,
    pub StepNo: ::core::ffi::c_int,
    pub ItemsFrozen: ::core::ffi::c_int,
    pub Ranges: ImVector_ImGuiListClipperRange,
}
impl ImGuiActivateFlags {
    pub const None: ImGuiActivateFlags = ImGuiActivateFlags(0);
    pub const PreferInput: ImGuiActivateFlags = ImGuiActivateFlags(1);
    pub const PreferTweak: ImGuiActivateFlags = ImGuiActivateFlags(2);
    pub const TryToPreserveState: ImGuiActivateFlags = ImGuiActivateFlags(4);
    pub const FromTabbing: ImGuiActivateFlags = ImGuiActivateFlags(8);
    pub const FromShortcut: ImGuiActivateFlags = ImGuiActivateFlags(16);
    pub const FromFocusApi: ImGuiActivateFlags = ImGuiActivateFlags(32);
}
impl ::core::ops::BitOr<ImGuiActivateFlags> for ImGuiActivateFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiActivateFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiActivateFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiActivateFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiActivateFlags> for ImGuiActivateFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiActivateFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiActivateFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiActivateFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiActivateFlags(pub ::core::ffi::c_uint);
impl ImGuiScrollFlags {
    pub const None: ImGuiScrollFlags = ImGuiScrollFlags(0);
    pub const KeepVisibleEdgeX: ImGuiScrollFlags = ImGuiScrollFlags(1);
    pub const KeepVisibleEdgeY: ImGuiScrollFlags = ImGuiScrollFlags(2);
    pub const KeepVisibleCenterX: ImGuiScrollFlags = ImGuiScrollFlags(4);
    pub const KeepVisibleCenterY: ImGuiScrollFlags = ImGuiScrollFlags(8);
    pub const AlwaysCenterX: ImGuiScrollFlags = ImGuiScrollFlags(16);
    pub const AlwaysCenterY: ImGuiScrollFlags = ImGuiScrollFlags(32);
    pub const NoScrollParent: ImGuiScrollFlags = ImGuiScrollFlags(64);
    pub const MaskX_: ImGuiScrollFlags = ImGuiScrollFlags(21);
    pub const MaskY_: ImGuiScrollFlags = ImGuiScrollFlags(42);
}
impl ::core::ops::BitOr<ImGuiScrollFlags> for ImGuiScrollFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiScrollFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiScrollFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiScrollFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiScrollFlags> for ImGuiScrollFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiScrollFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiScrollFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiScrollFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiScrollFlags(pub ::core::ffi::c_uint);
impl ImGuiNavRenderCursorFlags {
    pub const None: ImGuiNavRenderCursorFlags = ImGuiNavRenderCursorFlags(0);
    pub const Compact: ImGuiNavRenderCursorFlags = ImGuiNavRenderCursorFlags(2);
    pub const AlwaysDraw: ImGuiNavRenderCursorFlags = ImGuiNavRenderCursorFlags(4);
    pub const NoRounding: ImGuiNavRenderCursorFlags = ImGuiNavRenderCursorFlags(8);
}
impl ::core::ops::BitOr<ImGuiNavRenderCursorFlags> for ImGuiNavRenderCursorFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiNavRenderCursorFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiNavRenderCursorFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiNavRenderCursorFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiNavRenderCursorFlags> for ImGuiNavRenderCursorFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiNavRenderCursorFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiNavRenderCursorFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiNavRenderCursorFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiNavRenderCursorFlags(pub ::core::ffi::c_uint);
impl ImGuiNavMoveFlags {
    pub const None: ImGuiNavMoveFlags = ImGuiNavMoveFlags(0);
    pub const LoopX: ImGuiNavMoveFlags = ImGuiNavMoveFlags(1);
    pub const LoopY: ImGuiNavMoveFlags = ImGuiNavMoveFlags(2);
    pub const WrapX: ImGuiNavMoveFlags = ImGuiNavMoveFlags(4);
    pub const WrapY: ImGuiNavMoveFlags = ImGuiNavMoveFlags(8);
    pub const WrapMask_: ImGuiNavMoveFlags = ImGuiNavMoveFlags(15);
    pub const AllowCurrentNavId: ImGuiNavMoveFlags = ImGuiNavMoveFlags(16);
    pub const AlsoScoreVisibleSet: ImGuiNavMoveFlags = ImGuiNavMoveFlags(32);
    pub const ScrollToEdgeY: ImGuiNavMoveFlags = ImGuiNavMoveFlags(64);
    pub const Forwarded: ImGuiNavMoveFlags = ImGuiNavMoveFlags(128);
    pub const DebugNoResult: ImGuiNavMoveFlags = ImGuiNavMoveFlags(256);
    pub const FocusApi: ImGuiNavMoveFlags = ImGuiNavMoveFlags(512);
    pub const IsTabbing: ImGuiNavMoveFlags = ImGuiNavMoveFlags(1024);
    pub const IsPageMove: ImGuiNavMoveFlags = ImGuiNavMoveFlags(2048);
    pub const Activate: ImGuiNavMoveFlags = ImGuiNavMoveFlags(4096);
    pub const NoSelect: ImGuiNavMoveFlags = ImGuiNavMoveFlags(8192);
    pub const NoSetNavCursorVisible: ImGuiNavMoveFlags = ImGuiNavMoveFlags(16384);
    pub const NoClearActiveId: ImGuiNavMoveFlags = ImGuiNavMoveFlags(32768);
}
impl ::core::ops::BitOr<ImGuiNavMoveFlags> for ImGuiNavMoveFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiNavMoveFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiNavMoveFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiNavMoveFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiNavMoveFlags> for ImGuiNavMoveFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiNavMoveFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiNavMoveFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiNavMoveFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiNavMoveFlags(pub ::core::ffi::c_uint);
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ImGuiNavLayer {
    Main = 0,
    Menu = 1,
    COUNT = 2,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiNavItemData {
    pub Window: *mut ImGuiWindow,
    pub ID: ImGuiID,
    pub FocusScopeId: ImGuiID,
    pub RectRel: ImRect_c,
    pub ItemFlags: ImGuiItemFlags,
    pub DistBox: f32,
    pub DistCenter: f32,
    pub DistAxial: f32,
    pub SelectionUserData: ImGuiSelectionUserData,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiFocusScopeData {
    pub ID: ImGuiID,
    pub WindowID: ImGuiID,
}
impl ImGuiTypingSelectFlags {
    pub const None: ImGuiTypingSelectFlags = ImGuiTypingSelectFlags(0);
    pub const AllowBackspace: ImGuiTypingSelectFlags = ImGuiTypingSelectFlags(1);
    pub const AllowSingleCharMode: ImGuiTypingSelectFlags = ImGuiTypingSelectFlags(2);
}
impl ::core::ops::BitOr<ImGuiTypingSelectFlags> for ImGuiTypingSelectFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiTypingSelectFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiTypingSelectFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiTypingSelectFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiTypingSelectFlags> for ImGuiTypingSelectFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiTypingSelectFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiTypingSelectFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiTypingSelectFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiTypingSelectFlags(pub ::core::ffi::c_uint);
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiTypingSelectRequest {
    pub Flags: ImGuiTypingSelectFlags,
    pub SearchBufferLen: ::core::ffi::c_int,
    pub SearchBuffer: *const ::core::ffi::c_char,
    pub SelectRequest: bool,
    pub SingleCharMode: bool,
    pub SingleCharSize: ImS8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiTypingSelectState {
    pub Request: ImGuiTypingSelectRequest,
    pub SearchBuffer: [::core::ffi::c_char; 64usize],
    pub FocusScope: ImGuiID,
    pub LastRequestFrame: ::core::ffi::c_int,
    pub LastRequestTime: f32,
    pub SingleCharModeLock: bool,
}
impl ImGuiOldColumnFlags {
    pub const None: ImGuiOldColumnFlags = ImGuiOldColumnFlags(0);
    pub const NoBorder: ImGuiOldColumnFlags = ImGuiOldColumnFlags(1);
    pub const NoResize: ImGuiOldColumnFlags = ImGuiOldColumnFlags(2);
    pub const NoPreserveWidths: ImGuiOldColumnFlags = ImGuiOldColumnFlags(4);
    pub const NoForceWithinWindow: ImGuiOldColumnFlags = ImGuiOldColumnFlags(8);
    pub const GrowParentContentsSize: ImGuiOldColumnFlags = ImGuiOldColumnFlags(16);
}
impl ::core::ops::BitOr<ImGuiOldColumnFlags> for ImGuiOldColumnFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiOldColumnFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiOldColumnFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiOldColumnFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiOldColumnFlags> for ImGuiOldColumnFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiOldColumnFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiOldColumnFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiOldColumnFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiOldColumnFlags(pub ::core::ffi::c_uint);
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiOldColumnData {
    pub OffsetNorm: f32,
    pub OffsetNormBeforeResize: f32,
    pub Flags: ImGuiOldColumnFlags,
    pub ClipRect: ImRect_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiOldColumnData {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiOldColumnData,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiOldColumns {
    pub ID: ImGuiID,
    pub Flags: ImGuiOldColumnFlags,
    pub IsFirstFrame: bool,
    pub IsBeingResized: bool,
    pub Current: ::core::ffi::c_int,
    pub Count: ::core::ffi::c_int,
    pub OffMinX: f32,
    pub OffMaxX: f32,
    pub LineMinY: f32,
    pub LineMaxY: f32,
    pub HostCursorPosY: f32,
    pub HostCursorMaxPosX: f32,
    pub HostInitialClipRect: ImRect_c,
    pub HostBackupClipRect: ImRect_c,
    pub HostBackupParentWorkRect: ImRect_c,
    pub Columns: ImVector_ImGuiOldColumnData,
    pub Splitter: ImDrawListSplitter,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiBoxSelectState {
    pub ID: ImGuiID,
    pub IsActive: bool,
    pub IsStarting: bool,
    pub IsStartedFromVoid: bool,
    pub IsStartedSetNavIdOnce: bool,
    pub RequestClear: bool,
    pub _bitfield_align_1: [u16; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
    pub StartPosRel: ImVec2_c,
    pub EndPosRel: ImVec2_c,
    pub ScrollAccum: ImVec2_c,
    pub Window: *mut ImGuiWindow,
    pub UnclipMode: bool,
    pub UnclipRect: ImRect_c,
    pub UnclipRects: [ImRect_c; 2usize],
    pub BoxSelectRectPrev: ImRect_c,
    pub BoxSelectRectCurr: ImRect_c,
}
impl ImGuiBoxSelectState {
    #[inline]
    pub fn KeyMods(&self) -> ImGuiKeyChord {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) }
    }
    #[inline]
    pub fn set_KeyMods(&mut self, val: ImGuiKeyChord) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(0usize, 16u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn KeyMods_raw(this: *const Self) -> ImGuiKeyChord {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                0usize,
                16u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_KeyMods_raw(this: *mut Self, val: ImGuiKeyChord) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                16u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(KeyMods: ImGuiKeyChord) -> __BindgenBitfieldUnit<[u8; 2usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 16u8, {
            let KeyMods: u32 = unsafe { ::core::mem::transmute(KeyMods) };
            KeyMods as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiMultiSelectTempData {
    pub IO: ImGuiMultiSelectIO,
    pub Storage: *mut ImGuiMultiSelectState,
    pub FocusScopeId: ImGuiID,
    pub Flags: ImGuiMultiSelectFlags,
    pub ScopeRectMin: ImVec2_c,
    pub BackupCursorMaxPos: ImVec2_c,
    pub BoxSelectId: ImGuiID,
    pub KeyMods: ImGuiKeyChord,
    pub LoopRequestSetAll: ImS8,
    pub IsEndIO: bool,
    pub IsFocused: bool,
    pub IsKeyboardSetRange: bool,
    pub NavIdPassedBy: bool,
    pub RangeSrcPassedBy: bool,
    pub RangeDstPassedBy: bool,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiMultiSelectState {
    pub Window: *mut ImGuiWindow,
    pub ID: ImGuiID,
    pub LastFrameActive: ::core::ffi::c_int,
    pub LastSelectionSize: ::core::ffi::c_int,
    pub RangeSelected: ImS8,
    pub NavIdSelected: ImS8,
    pub RangeSrcItem: ImGuiSelectionUserData,
    pub NavIdItem: ImGuiSelectionUserData,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiViewportP {
    pub _ImGuiViewport: ImGuiViewport,
    pub BgFgDrawListsLastTimeActive: [f32; 2usize],
    pub BgFgDrawLists: [*mut ImDrawList; 2usize],
    pub DrawDataP: ImDrawData,
    pub DrawDataBuilder: ImDrawDataBuilder,
    pub WorkInsetMin: ImVec2_c,
    pub WorkInsetMax: ImVec2_c,
    pub BuildWorkInsetMin: ImVec2_c,
    pub BuildWorkInsetMax: ImVec2_c,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiWindowSettings {
    pub ID: ImGuiID,
    pub Pos: ImVec2ih,
    pub Size: ImVec2ih,
    pub Collapsed: bool,
    pub IsChild: bool,
    pub WantApply: bool,
    pub WantDelete: bool,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiSettingsHandler {
    pub TypeName: *const ::core::ffi::c_char,
    pub TypeHash: ImGuiID,
    pub ClearAllFn: ::core::option::Option<unsafe extern "C" fn(ctx: *mut ImGuiContext, handler: *mut ImGuiSettingsHandler)>,
    pub ReadInitFn: ::core::option::Option<unsafe extern "C" fn(ctx: *mut ImGuiContext, handler: *mut ImGuiSettingsHandler)>,
    pub ReadOpenFn: ::core::option::Option<
        unsafe extern "C" fn(
            ctx: *mut ImGuiContext,
            handler: *mut ImGuiSettingsHandler,
            name: *const ::core::ffi::c_char,
        ) -> *mut ::core::ffi::c_void,
    >,
    pub ReadLineFn: ::core::option::Option<
        unsafe extern "C" fn(
            ctx: *mut ImGuiContext,
            handler: *mut ImGuiSettingsHandler,
            entry: *mut ::core::ffi::c_void,
            line: *const ::core::ffi::c_char,
        ),
    >,
    pub ApplyAllFn: ::core::option::Option<unsafe extern "C" fn(ctx: *mut ImGuiContext, handler: *mut ImGuiSettingsHandler)>,
    pub WriteAllFn: ::core::option::Option<
        unsafe extern "C" fn(ctx: *mut ImGuiContext, handler: *mut ImGuiSettingsHandler, out_buf: *mut ImGuiTextBuffer),
    >,
    pub UserData: *mut ::core::ffi::c_void,
}
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ImGuiLocKey {
    VersionStr = 0,
    TableSizeOne = 1,
    TableSizeAllFit = 2,
    TableSizeAllDefault = 3,
    TableResetOrder = 4,
    WindowingMainMenuBar = 5,
    WindowingPopup = 6,
    WindowingUntitled = 7,
    OpenLink_s = 8,
    CopyLink = 9,
    COUNT = 10,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiLocEntry {
    pub Key: ImGuiLocKey,
    pub Text: *const ::core::ffi::c_char,
}
pub type ImGuiErrorCallback = ::core::option::Option<
    unsafe extern "C" fn(ctx: *mut ImGuiContext, user_data: *mut ::core::ffi::c_void, msg: *const ::core::ffi::c_char),
>;
impl ImGuiDebugLogFlags {
    pub const None: ImGuiDebugLogFlags = ImGuiDebugLogFlags(0);
    pub const EventError: ImGuiDebugLogFlags = ImGuiDebugLogFlags(1);
    pub const EventActiveId: ImGuiDebugLogFlags = ImGuiDebugLogFlags(2);
    pub const EventFocus: ImGuiDebugLogFlags = ImGuiDebugLogFlags(4);
    pub const EventPopup: ImGuiDebugLogFlags = ImGuiDebugLogFlags(8);
    pub const EventNav: ImGuiDebugLogFlags = ImGuiDebugLogFlags(16);
    pub const EventClipper: ImGuiDebugLogFlags = ImGuiDebugLogFlags(32);
    pub const EventSelection: ImGuiDebugLogFlags = ImGuiDebugLogFlags(64);
    pub const EventIO: ImGuiDebugLogFlags = ImGuiDebugLogFlags(128);
    pub const EventFont: ImGuiDebugLogFlags = ImGuiDebugLogFlags(256);
    pub const EventInputRouting: ImGuiDebugLogFlags = ImGuiDebugLogFlags(512);
    pub const EventDocking: ImGuiDebugLogFlags = ImGuiDebugLogFlags(1024);
    pub const EventViewport: ImGuiDebugLogFlags = ImGuiDebugLogFlags(2048);
    pub const EventMask_: ImGuiDebugLogFlags = ImGuiDebugLogFlags(4095);
    pub const OutputToTTY: ImGuiDebugLogFlags = ImGuiDebugLogFlags(1048576);
    pub const OutputToDebugger: ImGuiDebugLogFlags = ImGuiDebugLogFlags(2097152);
    pub const OutputToTestEngine: ImGuiDebugLogFlags = ImGuiDebugLogFlags(4194304);
}
impl ::core::ops::BitOr<ImGuiDebugLogFlags> for ImGuiDebugLogFlags {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiDebugLogFlags(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiDebugLogFlags {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiDebugLogFlags) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiDebugLogFlags> for ImGuiDebugLogFlags {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiDebugLogFlags(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiDebugLogFlags {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiDebugLogFlags) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiDebugLogFlags(pub ::core::ffi::c_uint);
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiDebugAllocEntry {
    pub FrameCount: ::core::ffi::c_int,
    pub AllocCount: ImS16,
    pub FreeCount: ImS16,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiDebugAllocInfo {
    pub TotalAllocCount: ::core::ffi::c_int,
    pub TotalFreeCount: ::core::ffi::c_int,
    pub LastEntriesIdx: ImS16,
    pub LastEntriesBuf: [ImGuiDebugAllocEntry; 6usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiMetricsConfig {
    pub ShowDebugLog: bool,
    pub ShowIDStackTool: bool,
    pub ShowWindowsRects: bool,
    pub ShowWindowsBeginOrder: bool,
    pub ShowTablesRects: bool,
    pub ShowDrawCmdMesh: bool,
    pub ShowDrawCmdBoundingBoxes: bool,
    pub ShowTextEncodingViewer: bool,
    pub ShowTextureUsedRect: bool,
    pub ShowWindowsRectsType: ::core::ffi::c_int,
    pub ShowTablesRectsType: ::core::ffi::c_int,
    pub HighlightMonitorIdx: ::core::ffi::c_int,
    pub HighlightViewportID: ImGuiID,
    pub ShowFontPreview: bool,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiStackLevelInfo {
    pub ID: ImGuiID,
    pub QueryFrameCount: ImS8,
    pub QuerySuccess: bool,
    pub DataType: ImS8,
    pub DescOffset: ::core::ffi::c_int,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiStackLevelInfo {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiStackLevelInfo,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiDebugItemPathQuery {
    pub MainID: ImGuiID,
    pub Active: bool,
    pub Complete: bool,
    pub Step: ImS8,
    pub Results: ImVector_ImGuiStackLevelInfo,
    pub ResultsDescBuf: ImGuiTextBuffer,
    pub ResultPathBuf: ImGuiTextBuffer,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiIDStackTool {
    pub OptHexEncodeNonAsciiChars: bool,
    pub OptCopyToClipboardOnCtrlC: bool,
    pub LastActiveFrame: ::core::ffi::c_int,
    pub CopyToClipboardLastTime: f32,
}
pub type ImGuiContextHookCallback =
    ::core::option::Option<unsafe extern "C" fn(ctx: *mut ImGuiContext, hook: *mut ImGuiContextHook)>;
#[repr(u32)]
#[non_exhaustive]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum ImGuiContextHookType {
    NewFramePre = 0,
    NewFramePost = 1,
    EndFramePre = 2,
    EndFramePost = 3,
    RenderPre = 4,
    RenderPost = 5,
    Shutdown = 6,
    PendingRemoval_ = 7,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiContextHook {
    pub HookId: ImGuiID,
    pub Type: ImGuiContextHookType,
    pub Owner: ImGuiID,
    pub Callback: ImGuiContextHookCallback,
    pub UserData: *mut ::core::ffi::c_void,
}
pub type ImGuiDemoMarkerCallback = ::core::option::Option<
    unsafe extern "C" fn(file: *const ::core::ffi::c_char, line: ::core::ffi::c_int, section: *const ::core::ffi::c_char),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImFontAtlasPtr {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut *mut ImFontAtlas,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiInputEvent {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiInputEvent,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiWindowPtr {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut *mut ImGuiWindow,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiWindowStackData {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiWindowStackData,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiColorMod {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiColorMod,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiStyleMod {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiStyleMod,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImFontStackData {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImFontStackData,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiFocusScopeData {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiFocusScopeData,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiItemFlags {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiItemFlags,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiGroupData {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiGroupData,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiPopupData {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiPopupData,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiTreeNodeStackData {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiTreeNodeStackData,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiViewportPPtr {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut *mut ImGuiViewportP,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_unsigned_char {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ::core::ffi::c_uchar,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiListClipperData {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiListClipperData,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiTableTempData {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiTableTempData,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiTable {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiTable,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImPool_ImGuiTable {
    pub Buf: ImVector_ImGuiTable,
    pub Map: ImGuiStorage,
    pub FreeIdx: ImPoolIdx,
    pub AliveCount: ImPoolIdx,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiTabBar {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiTabBar,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImPool_ImGuiTabBar {
    pub Buf: ImVector_ImGuiTabBar,
    pub Map: ImGuiStorage,
    pub FreeIdx: ImPoolIdx,
    pub AliveCount: ImPoolIdx,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiPtrOrIndex {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiPtrOrIndex,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiShrinkWidthItem {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiShrinkWidthItem,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiMultiSelectTempData {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiMultiSelectTempData,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiMultiSelectState {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiMultiSelectState,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImPool_ImGuiMultiSelectState {
    pub Buf: ImVector_ImGuiMultiSelectState,
    pub Map: ImGuiStorage,
    pub FreeIdx: ImPoolIdx,
    pub AliveCount: ImPoolIdx,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiID {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiID,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiSettingsHandler {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiSettingsHandler,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImChunkStream_ImGuiWindowSettings {
    pub Buf: ImVector_char,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImChunkStream_ImGuiTableSettings {
    pub Buf: ImVector_char,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiContextHook {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiContextHook,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiContext {
    pub Initialized: bool,
    pub WithinFrameScope: bool,
    pub WithinFrameScopeWithImplicitWindow: bool,
    pub TestEngineHookItems: bool,
    pub FrameCount: ::core::ffi::c_int,
    pub FrameCountEnded: ::core::ffi::c_int,
    pub FrameCountRendered: ::core::ffi::c_int,
    pub Time: f64,
    pub ContextName: [::core::ffi::c_char; 16usize],
    pub IO: ImGuiIO,
    pub PlatformIO: ImGuiPlatformIO,
    pub Style: ImGuiStyle,
    pub FontAtlases: ImVector_ImFontAtlasPtr,
    pub Font: *mut ImFont,
    pub FontBaked: *mut ImFontBaked,
    pub FontSize: f32,
    pub FontSizeBase: f32,
    pub FontBakedScale: f32,
    pub FontRasterizerDensity: f32,
    pub CurrentDpiScale: f32,
    pub DrawListSharedData: ImDrawListSharedData,
    pub WithinEndChildID: ImGuiID,
    pub WithinEndPopupID: ImGuiID,
    pub TestEngine: *mut ::core::ffi::c_void,
    pub InputEventsQueue: ImVector_ImGuiInputEvent,
    pub InputEventsTrail: ImVector_ImGuiInputEvent,
    pub InputEventsNextMouseSource: ImGuiMouseSource,
    pub InputEventsNextEventId: ImU32,
    pub Windows: ImVector_ImGuiWindowPtr,
    pub WindowsFocusOrder: ImVector_ImGuiWindowPtr,
    pub WindowsTempSortBuffer: ImVector_ImGuiWindowPtr,
    pub CurrentWindowStack: ImVector_ImGuiWindowStackData,
    pub WindowsById: ImGuiStorage,
    pub WindowsActiveCount: ::core::ffi::c_int,
    pub WindowsBorderHoverPadding: f32,
    pub DebugBreakInWindow: ImGuiID,
    pub CurrentWindow: *mut ImGuiWindow,
    pub HoveredWindow: *mut ImGuiWindow,
    pub HoveredWindowUnderMovingWindow: *mut ImGuiWindow,
    pub HoveredWindowBeforeClear: *mut ImGuiWindow,
    pub MovingWindow: *mut ImGuiWindow,
    pub WheelingWindow: *mut ImGuiWindow,
    pub WheelingWindowRefMousePos: ImVec2_c,
    pub WheelingWindowStartFrame: ::core::ffi::c_int,
    pub WheelingWindowScrolledFrame: ::core::ffi::c_int,
    pub WheelingWindowReleaseTimer: f32,
    pub WheelingWindowWheelRemainder: ImVec2_c,
    pub WheelingAxisAvg: ImVec2_c,
    pub DebugDrawIdConflictsId: ImGuiID,
    pub DebugHookIdInfoId: ImGuiID,
    pub HoveredId: ImGuiID,
    pub HoveredIdPreviousFrame: ImGuiID,
    pub HoveredIdPreviousFrameItemCount: ::core::ffi::c_int,
    pub HoveredIdTimer: f32,
    pub HoveredIdNotActiveTimer: f32,
    pub HoveredIdAllowOverlap: bool,
    pub HoveredIdIsDisabled: bool,
    pub ItemUnclipByLog: bool,
    pub ActiveId: ImGuiID,
    pub ActiveIdIsAlive: ImGuiID,
    pub ActiveIdTimer: f32,
    pub ActiveIdIsJustActivated: bool,
    pub ActiveIdAllowOverlap: bool,
    pub ActiveIdNoClearOnFocusLoss: bool,
    pub ActiveIdHasBeenPressedBefore: bool,
    pub ActiveIdHasBeenEditedBefore: bool,
    pub ActiveIdHasBeenEditedThisFrame: bool,
    pub ActiveIdFromShortcut: bool,
    pub ActiveIdMouseButton: ImS8,
    pub ActiveIdDisabledId: ImGuiID,
    pub ActiveIdClickOffset: ImVec2_c,
    pub ActiveIdSource: ImGuiInputSource,
    pub ActiveIdWindow: *mut ImGuiWindow,
    pub ActiveIdPreviousFrame: ImGuiID,
    pub DeactivatedItemData: ImGuiDeactivatedItemData,
    pub ActiveIdValueOnActivation: ImGuiDataTypeStorage,
    pub LastActiveId: ImGuiID,
    pub LastActiveIdTimer: f32,
    pub LastKeyModsChangeTime: f64,
    pub LastKeyModsChangeFromNoneTime: f64,
    pub LastKeyboardKeyPressTime: f64,
    pub KeysMayBeCharInput: ImBitArrayForNamedKeys,
    pub KeysOwnerData: [ImGuiKeyOwnerData; 155usize],
    pub KeysRoutingTable: ImGuiKeyRoutingTable,
    pub ActiveIdUsingNavDirMask: ImU32,
    pub ActiveIdUsingAllKeyboardKeys: bool,
    pub DebugBreakInShortcutRouting: ImGuiKeyChord,
    pub CurrentFocusScopeId: ImGuiID,
    pub CurrentItemFlags: ImGuiItemFlags,
    pub DebugLocateId: ImGuiID,
    pub NextItemData: ImGuiNextItemData,
    pub LastItemData: ImGuiLastItemData,
    pub NextWindowData: ImGuiNextWindowData,
    pub DebugShowGroupRects: bool,
    pub GcCompactAll: bool,
    pub DebugFlashStyleColorIdx: ImGuiCol,
    pub ColorStack: ImVector_ImGuiColorMod,
    pub StyleVarStack: ImVector_ImGuiStyleMod,
    pub FontStack: ImVector_ImFontStackData,
    pub FocusScopeStack: ImVector_ImGuiFocusScopeData,
    pub ItemFlagsStack: ImVector_ImGuiItemFlags,
    pub GroupStack: ImVector_ImGuiGroupData,
    pub OpenPopupStack: ImVector_ImGuiPopupData,
    pub BeginPopupStack: ImVector_ImGuiPopupData,
    pub TreeNodeStack: ImVector_ImGuiTreeNodeStackData,
    pub Viewports: ImVector_ImGuiViewportPPtr,
    pub NavCursorVisible: bool,
    pub NavHighlightItemUnderNav: bool,
    pub NavMousePosDirty: bool,
    pub NavIdIsAlive: bool,
    pub NavId: ImGuiID,
    pub NavWindow: *mut ImGuiWindow,
    pub NavFocusScopeId: ImGuiID,
    pub NavLayer: ImGuiNavLayer,
    pub NavIdItemFlags: ImGuiItemFlags,
    pub NavActivateId: ImGuiID,
    pub NavActivateDownId: ImGuiID,
    pub NavActivatePressedId: ImGuiID,
    pub NavActivateFlags: ImGuiActivateFlags,
    pub NavFocusRoute: ImVector_ImGuiFocusScopeData,
    pub NavHighlightActivatedId: ImGuiID,
    pub NavHighlightActivatedTimer: f32,
    pub NavOpenContextMenuItemId: ImGuiID,
    pub NavOpenContextMenuWindowId: ImGuiID,
    pub NavNextActivateId: ImGuiID,
    pub NavNextActivateFlags: ImGuiActivateFlags,
    pub NavInputSource: ImGuiInputSource,
    pub NavLastValidSelectionUserData: ImGuiSelectionUserData,
    pub NavCursorHideFrames: ImS8,
    pub NavAnyRequest: bool,
    pub NavInitRequest: bool,
    pub NavInitRequestFromMove: bool,
    pub NavInitResult: ImGuiNavItemData,
    pub NavMoveSubmitted: bool,
    pub NavMoveScoringItems: bool,
    pub NavMoveForwardToNextFrame: bool,
    pub NavMoveFlags: ImGuiNavMoveFlags,
    pub NavMoveScrollFlags: ImGuiScrollFlags,
    pub NavMoveKeyMods: ImGuiKeyChord,
    pub NavMoveDir: ImGuiDir,
    pub NavMoveDirForDebug: ImGuiDir,
    pub NavMoveClipDir: ImGuiDir,
    pub NavScoringRect: ImRect_c,
    pub NavScoringNoClipRect: ImRect_c,
    pub NavScoringDebugCount: ::core::ffi::c_int,
    pub NavTabbingDir: ::core::ffi::c_int,
    pub NavTabbingCounter: ::core::ffi::c_int,
    pub NavMoveResultLocal: ImGuiNavItemData,
    pub NavMoveResultLocalVisible: ImGuiNavItemData,
    pub NavMoveResultOther: ImGuiNavItemData,
    pub NavTabbingResultFirst: ImGuiNavItemData,
    pub NavJustMovedFromFocusScopeId: ImGuiID,
    pub NavJustMovedToId: ImGuiID,
    pub NavJustMovedToFocusScopeId: ImGuiID,
    pub NavJustMovedToKeyMods: ImGuiKeyChord,
    pub NavJustMovedToIsTabbing: bool,
    pub NavJustMovedToHasSelectionData: bool,
    pub ConfigNavEnableTabbing: bool,
    pub ConfigNavWindowingWithGamepad: bool,
    pub ConfigNavWindowingKeyNext: ImGuiKeyChord,
    pub ConfigNavWindowingKeyPrev: ImGuiKeyChord,
    pub NavWindowingTarget: *mut ImGuiWindow,
    pub NavWindowingTargetAnim: *mut ImGuiWindow,
    pub NavWindowingListWindow: *mut ImGuiWindow,
    pub NavWindowingTimer: f32,
    pub NavWindowingHighlightAlpha: f32,
    pub NavWindowingInputSource: ImGuiInputSource,
    pub NavWindowingToggleLayer: bool,
    pub NavWindowingToggleKey: ImGuiKey,
    pub NavWindowingAccumDeltaPos: ImVec2_c,
    pub NavWindowingAccumDeltaSize: ImVec2_c,
    pub DimBgRatio: f32,
    pub DragDropActive: bool,
    pub DragDropWithinSource: bool,
    pub DragDropWithinTarget: bool,
    pub DragDropSourceFlags: ImGuiDragDropFlags,
    pub DragDropSourceFrameCount: ::core::ffi::c_int,
    pub DragDropMouseButton: ::core::ffi::c_int,
    pub DragDropPayload: ImGuiPayload,
    pub DragDropTargetRect: ImRect_c,
    pub DragDropTargetClipRect: ImRect_c,
    pub DragDropTargetId: ImGuiID,
    pub DragDropTargetFullViewport: ImGuiID,
    pub DragDropAcceptFlagsCurr: ImGuiDragDropFlags,
    pub DragDropAcceptFlagsPrev: ImGuiDragDropFlags,
    pub DragDropAcceptIdCurrRectSurface: f32,
    pub DragDropAcceptIdCurr: ImGuiID,
    pub DragDropAcceptIdPrev: ImGuiID,
    pub DragDropAcceptFrameCount: ::core::ffi::c_int,
    pub DragDropHoldJustPressedId: ImGuiID,
    pub DragDropPayloadBufHeap: ImVector_unsigned_char,
    pub DragDropPayloadBufLocal: [::core::ffi::c_uchar; 16usize],
    pub ClipperTempDataStacked: ::core::ffi::c_int,
    pub ClipperTempData: ImVector_ImGuiListClipperData,
    pub CurrentTable: *mut ImGuiTable,
    pub DebugBreakInTable: ImGuiID,
    pub TablesTempDataStacked: ::core::ffi::c_int,
    pub TablesTempData: ImVector_ImGuiTableTempData,
    pub Tables: ImPool_ImGuiTable,
    pub TablesLastTimeActive: ImVector_float,
    pub DrawChannelsTempMergeBuffer: ImVector_ImDrawChannel,
    pub CurrentTabBar: *mut ImGuiTabBar,
    pub TabBars: ImPool_ImGuiTabBar,
    pub CurrentTabBarStack: ImVector_ImGuiPtrOrIndex,
    pub ShrinkWidthBuffer: ImVector_ImGuiShrinkWidthItem,
    pub BoxSelectState: ImGuiBoxSelectState,
    pub CurrentMultiSelect: *mut ImGuiMultiSelectTempData,
    pub MultiSelectTempDataStacked: ::core::ffi::c_int,
    pub MultiSelectTempData: ImVector_ImGuiMultiSelectTempData,
    pub MultiSelectStorage: ImPool_ImGuiMultiSelectState,
    pub HoverItemDelayId: ImGuiID,
    pub HoverItemDelayIdPreviousFrame: ImGuiID,
    pub HoverItemDelayTimer: f32,
    pub HoverItemDelayClearTimer: f32,
    pub HoverItemUnlockedStationaryId: ImGuiID,
    pub HoverWindowUnlockedStationaryId: ImGuiID,
    pub MouseCursor: ImGuiMouseCursor,
    pub MouseStationaryTimer: f32,
    pub MouseLastValidPos: ImVec2_c,
    pub InputTextState: ImGuiInputTextState,
    pub InputTextLineIndex: ImGuiTextIndex,
    pub InputTextDeactivatedState: ImGuiInputTextDeactivatedState,
    pub InputTextPasswordFontBackupBaked: ImFontBaked,
    pub InputTextPasswordFontBackupFlags: ImFontFlags,
    pub InputTextReactivateId: ImGuiID,
    pub TempInputId: ImGuiID,
    pub DataTypeZeroValue: ImGuiDataTypeStorage,
    pub BeginMenuDepth: ::core::ffi::c_int,
    pub BeginComboDepth: ::core::ffi::c_int,
    pub ColorEditOptions: ImGuiColorEditFlags,
    pub ColorEditCurrentID: ImGuiID,
    pub ColorEditSavedID: ImGuiID,
    pub ColorEditSavedHue: f32,
    pub ColorEditSavedSat: f32,
    pub ColorEditSavedColor: ImU32,
    pub ColorPickerRef: ImVec4_c,
    pub ComboPreviewData: ImGuiComboPreviewData,
    pub WindowResizeBorderExpectedRect: ImRect_c,
    pub WindowResizeRelativeMode: bool,
    pub ScrollbarSeekMode: ::core::ffi::c_short,
    pub ScrollbarClickDeltaToGrabCenter: f32,
    pub SliderGrabClickOffset: f32,
    pub SliderCurrentAccum: f32,
    pub SliderCurrentAccumDirty: bool,
    pub DragCurrentAccumDirty: bool,
    pub DragCurrentAccum: f32,
    pub DragSpeedDefaultRatio: f32,
    pub DisabledAlphaBackup: f32,
    pub DisabledStackSize: ::core::ffi::c_short,
    pub TooltipOverrideCount: ::core::ffi::c_short,
    pub TooltipPreviousWindow: *mut ImGuiWindow,
    pub ClipboardHandlerData: ImVector_char,
    pub MenusIdSubmittedThisFrame: ImVector_ImGuiID,
    pub TypingSelectState: ImGuiTypingSelectState,
    pub PlatformImeData: ImGuiPlatformImeData,
    pub PlatformImeDataPrev: ImGuiPlatformImeData,
    pub UserTextures: ImVector_ImTextureDataPtr,
    pub SettingsLoaded: bool,
    pub SettingsDirtyTimer: f32,
    pub SettingsIniData: ImGuiTextBuffer,
    pub SettingsHandlers: ImVector_ImGuiSettingsHandler,
    pub SettingsWindows: ImChunkStream_ImGuiWindowSettings,
    pub SettingsTables: ImChunkStream_ImGuiTableSettings,
    pub Hooks: ImVector_ImGuiContextHook,
    pub HookIdNext: ImGuiID,
    pub DemoMarkerCallback: ImGuiDemoMarkerCallback,
    pub LocalizationTable: [*const ::core::ffi::c_char; 10usize],
    pub LogEnabled: bool,
    pub LogLineFirstItem: bool,
    pub LogFlags: ImGuiLogFlags,
    pub LogWindow: *mut ImGuiWindow,
    pub LogFile: ImFileHandle,
    pub LogBuffer: ImGuiTextBuffer,
    pub LogNextPrefix: *const ::core::ffi::c_char,
    pub LogNextSuffix: *const ::core::ffi::c_char,
    pub LogLinePosY: f32,
    pub LogDepthRef: ::core::ffi::c_int,
    pub LogDepthToExpand: ::core::ffi::c_int,
    pub LogDepthToExpandDefault: ::core::ffi::c_int,
    pub ErrorCallback: ImGuiErrorCallback,
    pub ErrorCallbackUserData: *mut ::core::ffi::c_void,
    pub ErrorTooltipLockedPos: ImVec2_c,
    pub ErrorFirst: bool,
    pub ErrorCountCurrentFrame: ::core::ffi::c_int,
    pub StackSizesInNewFrame: ImGuiErrorRecoveryState,
    pub StackSizesInBeginForCurrentWindow: *mut ImGuiErrorRecoveryState,
    pub DebugDrawIdConflictsCount: ::core::ffi::c_int,
    pub DebugLogFlags: ImGuiDebugLogFlags,
    pub DebugLogBuf: ImGuiTextBuffer,
    pub DebugLogIndex: ImGuiTextIndex,
    pub DebugLogSkippedErrors: ::core::ffi::c_int,
    pub DebugLogAutoDisableFlags: ImGuiDebugLogFlags,
    pub DebugLogAutoDisableFrames: ImU8,
    pub DebugLocateFrames: ImU8,
    pub DebugBreakInLocateId: bool,
    pub DebugBreakKeyChord: ImGuiKeyChord,
    pub DebugBeginReturnValueCullDepth: ImS8,
    pub DebugItemPickerActive: bool,
    pub DebugItemPickerMouseButton: ImU8,
    pub DebugItemPickerBreakId: ImGuiID,
    pub DebugFlashStyleColorTime: f32,
    pub DebugFlashStyleColorBackup: ImVec4_c,
    pub DebugMetricsConfig: ImGuiMetricsConfig,
    pub DebugItemPathQuery: ImGuiDebugItemPathQuery,
    pub DebugIDStackTool: ImGuiIDStackTool,
    pub DebugAllocInfo: ImGuiDebugAllocInfo,
    pub FramerateSecPerFrame: [f32; 60usize],
    pub FramerateSecPerFrameIdx: ::core::ffi::c_int,
    pub FramerateSecPerFrameCount: ::core::ffi::c_int,
    pub FramerateSecPerFrameAccum: f32,
    pub WantCaptureMouseNextFrame: ::core::ffi::c_int,
    pub WantCaptureKeyboardNextFrame: ::core::ffi::c_int,
    pub WantTextInputNextFrame: ::core::ffi::c_int,
    pub TempBuffer: ImVector_char,
    pub TempKeychordName: [::core::ffi::c_char; 64usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiWindowTempData {
    pub CursorPos: ImVec2_c,
    pub CursorPosPrevLine: ImVec2_c,
    pub CursorStartPos: ImVec2_c,
    pub CursorMaxPos: ImVec2_c,
    pub IdealMaxPos: ImVec2_c,
    pub CurrLineSize: ImVec2_c,
    pub PrevLineSize: ImVec2_c,
    pub CurrLineTextBaseOffset: f32,
    pub PrevLineTextBaseOffset: f32,
    pub IsSameLine: bool,
    pub IsSetPos: bool,
    pub Indent: ImVec1,
    pub ColumnsOffset: ImVec1,
    pub GroupOffset: ImVec1,
    pub CursorStartPosLossyness: ImVec2_c,
    pub NavLayerCurrent: ImGuiNavLayer,
    pub NavLayersActiveMask: ::core::ffi::c_short,
    pub NavLayersActiveMaskNext: ::core::ffi::c_short,
    pub NavIsScrollPushableX: bool,
    pub NavHideHighlightOneFrame: bool,
    pub NavWindowHasScrollY: bool,
    pub MenuBarAppending: bool,
    pub MenuBarOffset: ImVec2_c,
    pub MenuColumns: ImGuiMenuColumns,
    pub TreeDepth: ::core::ffi::c_int,
    pub TreeHasStackDataDepthMask: ImU32,
    pub TreeRecordsClippedNodesY2Mask: ImU32,
    pub ChildWindows: ImVector_ImGuiWindowPtr,
    pub StateStorage: *mut ImGuiStorage,
    pub CurrentColumns: *mut ImGuiOldColumns,
    pub CurrentTableIdx: ::core::ffi::c_int,
    pub LayoutType: ImGuiLayoutType,
    pub ParentLayoutType: ImGuiLayoutType,
    pub ModalDimBgColor: ImU32,
    pub WindowItemStatusFlags: ImGuiItemStatusFlags,
    pub ChildItemStatusFlags: ImGuiItemStatusFlags,
    pub ItemWidth: f32,
    pub ItemWidthDefault: f32,
    pub TextWrapPos: f32,
    pub ItemWidthStack: ImVector_float,
    pub TextWrapPosStack: ImVector_float,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiOldColumns {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiOldColumns,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiWindow {
    pub Ctx: *mut ImGuiContext,
    pub Name: *mut ::core::ffi::c_char,
    pub ID: ImGuiID,
    pub Flags: ImGuiWindowFlags,
    pub ChildFlags: ImGuiChildFlags,
    pub Viewport: *mut ImGuiViewportP,
    pub Pos: ImVec2_c,
    pub Size: ImVec2_c,
    pub SizeFull: ImVec2_c,
    pub ContentSize: ImVec2_c,
    pub ContentSizeIdeal: ImVec2_c,
    pub ContentSizeExplicit: ImVec2_c,
    pub WindowPadding: ImVec2_c,
    pub WindowRounding: f32,
    pub WindowBorderSize: f32,
    pub TitleBarHeight: f32,
    pub MenuBarHeight: f32,
    pub DecoOuterSizeX1: f32,
    pub DecoOuterSizeY1: f32,
    pub DecoOuterSizeX2: f32,
    pub DecoOuterSizeY2: f32,
    pub DecoInnerSizeX1: f32,
    pub DecoInnerSizeY1: f32,
    pub NameBufLen: ::core::ffi::c_int,
    pub MoveId: ImGuiID,
    pub ChildId: ImGuiID,
    pub PopupId: ImGuiID,
    pub Scroll: ImVec2_c,
    pub ScrollMax: ImVec2_c,
    pub ScrollTarget: ImVec2_c,
    pub ScrollTargetCenterRatio: ImVec2_c,
    pub ScrollTargetEdgeSnapDist: ImVec2_c,
    pub ScrollbarSizes: ImVec2_c,
    pub ScrollbarX: bool,
    pub ScrollbarY: bool,
    pub ScrollbarXStabilizeEnabled: bool,
    pub ScrollbarXStabilizeToggledHistory: ImU8,
    pub Active: bool,
    pub WasActive: bool,
    pub WriteAccessed: bool,
    pub Collapsed: bool,
    pub WantCollapseToggle: bool,
    pub SkipItems: bool,
    pub SkipRefresh: bool,
    pub Appearing: bool,
    pub Hidden: bool,
    pub IsFallbackWindow: bool,
    pub IsExplicitChild: bool,
    pub HasCloseButton: bool,
    pub ResizeBorderHovered: ::core::ffi::c_schar,
    pub ResizeBorderHeld: ::core::ffi::c_schar,
    pub BeginCount: ::core::ffi::c_short,
    pub BeginCountPreviousFrame: ::core::ffi::c_short,
    pub BeginOrderWithinParent: ::core::ffi::c_short,
    pub BeginOrderWithinContext: ::core::ffi::c_short,
    pub FocusOrder: ::core::ffi::c_short,
    pub AutoPosLastDirection: ImGuiDir,
    pub AutoFitFramesX: ImS8,
    pub AutoFitFramesY: ImS8,
    pub AutoFitOnlyGrows: bool,
    pub HiddenFramesCanSkipItems: ImS8,
    pub HiddenFramesCannotSkipItems: ImS8,
    pub HiddenFramesForRenderOnly: ImS8,
    pub DisableInputsFrames: ImS8,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
    pub SetWindowPosVal: ImVec2_c,
    pub SetWindowPosPivot: ImVec2_c,
    pub IDStack: ImVector_ImGuiID,
    pub DC: ImGuiWindowTempData,
    pub OuterRectClipped: ImRect_c,
    pub InnerRect: ImRect_c,
    pub InnerClipRect: ImRect_c,
    pub WorkRect: ImRect_c,
    pub ParentWorkRect: ImRect_c,
    pub ClipRect: ImRect_c,
    pub ContentRegionRect: ImRect_c,
    pub HitTestHoleSize: ImVec2ih,
    pub HitTestHoleOffset: ImVec2ih,
    pub LastFrameActive: ::core::ffi::c_int,
    pub LastTimeActive: f32,
    pub StateStorage: ImGuiStorage,
    pub ColumnsStorage: ImVector_ImGuiOldColumns,
    pub FontWindowScale: f32,
    pub FontWindowScaleParents: f32,
    pub FontRefSize: f32,
    pub SettingsOffset: ::core::ffi::c_int,
    pub DrawList: *mut ImDrawList,
    pub DrawListInst: ImDrawList,
    pub ParentWindow: *mut ImGuiWindow,
    pub ParentWindowInBeginStack: *mut ImGuiWindow,
    pub RootWindow: *mut ImGuiWindow,
    pub RootWindowPopupTree: *mut ImGuiWindow,
    pub RootWindowForTitleBarHighlight: *mut ImGuiWindow,
    pub RootWindowForNav: *mut ImGuiWindow,
    pub ParentWindowForFocusRoute: *mut ImGuiWindow,
    pub NavLastChildNavWindow: *mut ImGuiWindow,
    pub NavLastIds: [ImGuiID; 2usize],
    pub NavRectRel: [ImRect_c; 2usize],
    pub NavPreferredScoringPosRel: [ImVec2_c; 2usize],
    pub NavRootFocusScopeId: ImGuiID,
    pub MemoryDrawListIdxCapacity: ::core::ffi::c_int,
    pub MemoryDrawListVtxCapacity: ::core::ffi::c_int,
    pub MemoryCompacted: bool,
}
impl ImGuiWindow {
    #[inline]
    pub fn BgClickFlags(&self) -> ImGuiWindowBgClickFlags {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_BgClickFlags(&mut self, val: ImGuiWindowBgClickFlags) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(0usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn BgClickFlags_raw(this: *const Self) -> ImGuiWindowBgClickFlags {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                0usize,
                8u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_BgClickFlags_raw(this: *mut Self, val: ImGuiWindowBgClickFlags) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                8u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn SetWindowPosAllowFlags(&self) -> ImGuiCond {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_SetWindowPosAllowFlags(&mut self, val: ImGuiCond) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(8usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn SetWindowPosAllowFlags_raw(this: *const Self) -> ImGuiCond {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                8usize,
                8u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_SetWindowPosAllowFlags_raw(this: *mut Self, val: ImGuiCond) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                8usize,
                8u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn SetWindowSizeAllowFlags(&self) -> ImGuiCond {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_SetWindowSizeAllowFlags(&mut self, val: ImGuiCond) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(16usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn SetWindowSizeAllowFlags_raw(this: *const Self) -> ImGuiCond {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                16usize,
                8u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_SetWindowSizeAllowFlags_raw(this: *mut Self, val: ImGuiCond) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                16usize,
                8u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn SetWindowCollapsedAllowFlags(&self) -> ImGuiCond {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_SetWindowCollapsedAllowFlags(&mut self, val: ImGuiCond) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(24usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn SetWindowCollapsedAllowFlags_raw(this: *const Self) -> ImGuiCond {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                24usize,
                8u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_SetWindowCollapsedAllowFlags_raw(this: *mut Self, val: ImGuiCond) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                24usize,
                8u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        BgClickFlags: ImGuiWindowBgClickFlags,
        SetWindowPosAllowFlags: ImGuiCond,
        SetWindowSizeAllowFlags: ImGuiCond,
        SetWindowCollapsedAllowFlags: ImGuiCond,
    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 8u8, {
            let BgClickFlags: u32 = unsafe { ::core::mem::transmute(BgClickFlags) };
            BgClickFlags as u64
        });
        __bindgen_bitfield_unit.set(8usize, 8u8, {
            let SetWindowPosAllowFlags: u32 = unsafe { ::core::mem::transmute(SetWindowPosAllowFlags) };
            SetWindowPosAllowFlags as u64
        });
        __bindgen_bitfield_unit.set(16usize, 8u8, {
            let SetWindowSizeAllowFlags: u32 = unsafe { ::core::mem::transmute(SetWindowSizeAllowFlags) };
            SetWindowSizeAllowFlags as u64
        });
        __bindgen_bitfield_unit.set(24usize, 8u8, {
            let SetWindowCollapsedAllowFlags: u32 = unsafe { ::core::mem::transmute(SetWindowCollapsedAllowFlags) };
            SetWindowCollapsedAllowFlags as u64
        });
        __bindgen_bitfield_unit
    }
}
impl ImGuiTabBarFlagsPrivate {
    pub const ImGuiTabBarFlags_DockNode: ImGuiTabBarFlagsPrivate = ImGuiTabBarFlagsPrivate(1048576);
    pub const ImGuiTabBarFlags_IsFocused: ImGuiTabBarFlagsPrivate = ImGuiTabBarFlagsPrivate(2097152);
    pub const ImGuiTabBarFlags_SaveSettings: ImGuiTabBarFlagsPrivate = ImGuiTabBarFlagsPrivate(4194304);
}
impl ::core::ops::BitOr<ImGuiTabBarFlagsPrivate> for ImGuiTabBarFlagsPrivate {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiTabBarFlagsPrivate(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiTabBarFlagsPrivate {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiTabBarFlagsPrivate) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiTabBarFlagsPrivate> for ImGuiTabBarFlagsPrivate {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiTabBarFlagsPrivate(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiTabBarFlagsPrivate {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiTabBarFlagsPrivate) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiTabBarFlagsPrivate(pub ::core::ffi::c_uint);
impl ImGuiTabItemFlagsPrivate {
    pub const ImGuiTabItemFlags_SectionMask_: ImGuiTabItemFlagsPrivate = ImGuiTabItemFlagsPrivate(192);
    pub const ImGuiTabItemFlags_NoCloseButton: ImGuiTabItemFlagsPrivate = ImGuiTabItemFlagsPrivate(1048576);
    pub const ImGuiTabItemFlags_Button: ImGuiTabItemFlagsPrivate = ImGuiTabItemFlagsPrivate(2097152);
    pub const ImGuiTabItemFlags_Invisible: ImGuiTabItemFlagsPrivate = ImGuiTabItemFlagsPrivate(4194304);
}
impl ::core::ops::BitOr<ImGuiTabItemFlagsPrivate> for ImGuiTabItemFlagsPrivate {
    type Output = Self;
    #[inline]
    fn bitor(self, other: Self) -> Self {
        ImGuiTabItemFlagsPrivate(self.0 | other.0)
    }
}
impl ::core::ops::BitOrAssign for ImGuiTabItemFlagsPrivate {
    #[inline]
    fn bitor_assign(&mut self, rhs: ImGuiTabItemFlagsPrivate) {
        self.0 |= rhs.0;
    }
}
impl ::core::ops::BitAnd<ImGuiTabItemFlagsPrivate> for ImGuiTabItemFlagsPrivate {
    type Output = Self;
    #[inline]
    fn bitand(self, other: Self) -> Self {
        ImGuiTabItemFlagsPrivate(self.0 & other.0)
    }
}
impl ::core::ops::BitAndAssign for ImGuiTabItemFlagsPrivate {
    #[inline]
    fn bitand_assign(&mut self, rhs: ImGuiTabItemFlagsPrivate) {
        self.0 &= rhs.0;
    }
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ImGuiTabItemFlagsPrivate(pub ::core::ffi::c_uint);
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiTabItem {
    pub ID: ImGuiID,
    pub Flags: ImGuiTabItemFlags,
    pub LastFrameVisible: ::core::ffi::c_int,
    pub LastFrameSelected: ::core::ffi::c_int,
    pub Offset: f32,
    pub Width: f32,
    pub ContentWidth: f32,
    pub RequestedWidth: f32,
    pub NameOffset: ImS32,
    pub BeginOrder: ImS16,
    pub IndexDuringLayout: ImS16,
    pub WantClose: bool,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiTabItem {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiTabItem,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiTabBar {
    pub Window: *mut ImGuiWindow,
    pub Tabs: ImVector_ImGuiTabItem,
    pub Flags: ImGuiTabBarFlags,
    pub ID: ImGuiID,
    pub SelectedTabId: ImGuiID,
    pub NextSelectedTabId: ImGuiID,
    pub NextScrollToTabId: ImGuiID,
    pub VisibleTabId: ImGuiID,
    pub CurrFrameVisible: ::core::ffi::c_int,
    pub PrevFrameVisible: ::core::ffi::c_int,
    pub BarRect: ImRect_c,
    pub BarRectPrevWidth: f32,
    pub CurrTabsContentsHeight: f32,
    pub PrevTabsContentsHeight: f32,
    pub WidthAllTabs: f32,
    pub WidthAllTabsIdeal: f32,
    pub ScrollingAnim: f32,
    pub ScrollingTarget: f32,
    pub ScrollingTargetDistToVisibility: f32,
    pub ScrollingSpeed: f32,
    pub ScrollingRectMinX: f32,
    pub ScrollingRectMaxX: f32,
    pub SeparatorMinX: f32,
    pub SeparatorMaxX: f32,
    pub ReorderRequestTabId: ImGuiID,
    pub ReorderRequestOffset: ImS16,
    pub BeginCount: ImS8,
    pub WantLayout: bool,
    pub VisibleTabWasSubmitted: bool,
    pub TabsAddedNew: bool,
    pub ScrollButtonEnabled: bool,
    pub TabsActiveCount: ImS16,
    pub LastTabItemIdx: ImS16,
    pub ItemSpacingY: f32,
    pub FramePadding: ImVec2_c,
    pub BackupCursorPos: ImVec2_c,
    pub TabsNames: ImGuiTextBuffer,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiTableColumn {
    pub Flags: ImGuiTableColumnFlags,
    pub WidthGiven: f32,
    pub MinX: f32,
    pub MaxX: f32,
    pub WidthRequest: f32,
    pub WidthAuto: f32,
    pub WidthMax: f32,
    pub StretchWeight: f32,
    pub InitStretchWeightOrWidth: f32,
    pub ClipRect: ImRect_c,
    pub UserID: ImGuiID,
    pub WorkMinX: f32,
    pub WorkMaxX: f32,
    pub ItemWidth: f32,
    pub ContentMaxXFrozen: f32,
    pub ContentMaxXUnfrozen: f32,
    pub ContentMaxXHeadersUsed: f32,
    pub ContentMaxXHeadersIdeal: f32,
    pub NameOffset: ImS16,
    pub DisplayOrder: ImGuiTableColumnIdx,
    pub IndexWithinEnabledSet: ImGuiTableColumnIdx,
    pub PrevEnabledColumn: ImGuiTableColumnIdx,
    pub NextEnabledColumn: ImGuiTableColumnIdx,
    pub SortOrder: ImGuiTableColumnIdx,
    pub DrawChannelCurrent: ImGuiTableDrawChannelIdx,
    pub DrawChannelFrozen: ImGuiTableDrawChannelIdx,
    pub DrawChannelUnfrozen: ImGuiTableDrawChannelIdx,
    pub IsEnabled: bool,
    pub IsUserEnabled: bool,
    pub IsUserEnabledNextFrame: bool,
    pub IsVisibleX: bool,
    pub IsVisibleY: bool,
    pub IsRequestOutput: bool,
    pub IsSkipItems: bool,
    pub IsPreserveWidthAuto: bool,
    pub NavLayerCurrent: ImS8,
    pub AutoFitQueue: ImU8,
    pub CannotSkipItemsQueue: ImU8,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub SortDirectionsAvailList: ImU8,
}
impl ImGuiTableColumn {
    #[inline]
    pub fn SortDirection(&self) -> ImU8 {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u8) }
    }
    #[inline]
    pub fn set_SortDirection(&mut self, val: ImU8) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            self._bitfield_1.set(0usize, 2u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn SortDirection_raw(this: *const Self) -> ImU8 {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                0usize,
                2u8,
            ) as u8)
        }
    }
    #[inline]
    pub unsafe fn set_SortDirection_raw(this: *mut Self, val: ImU8) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                2u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn SortDirectionsAvailCount(&self) -> ImU8 {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u8) }
    }
    #[inline]
    pub fn set_SortDirectionsAvailCount(&mut self, val: ImU8) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            self._bitfield_1.set(2usize, 2u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn SortDirectionsAvailCount_raw(this: *const Self) -> ImU8 {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                2usize,
                2u8,
            ) as u8)
        }
    }
    #[inline]
    pub unsafe fn set_SortDirectionsAvailCount_raw(this: *mut Self, val: ImU8) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                2usize,
                2u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn SortDirectionsAvailMask(&self) -> ImU8 {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
    }
    #[inline]
    pub fn set_SortDirectionsAvailMask(&mut self, val: ImU8) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            self._bitfield_1.set(4usize, 4u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn SortDirectionsAvailMask_raw(this: *const Self) -> ImU8 {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                4usize,
                4u8,
            ) as u8)
        }
    }
    #[inline]
    pub unsafe fn set_SortDirectionsAvailMask_raw(this: *mut Self, val: ImU8) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                4usize,
                4u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        SortDirection: ImU8,
        SortDirectionsAvailCount: ImU8,
        SortDirectionsAvailMask: ImU8,
    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 2u8, {
            let SortDirection: u8 = unsafe { ::core::mem::transmute(SortDirection) };
            SortDirection as u64
        });
        __bindgen_bitfield_unit.set(2usize, 2u8, {
            let SortDirectionsAvailCount: u8 = unsafe { ::core::mem::transmute(SortDirectionsAvailCount) };
            SortDirectionsAvailCount as u64
        });
        __bindgen_bitfield_unit.set(4usize, 4u8, {
            let SortDirectionsAvailMask: u8 = unsafe { ::core::mem::transmute(SortDirectionsAvailMask) };
            SortDirectionsAvailMask as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiTableCellData {
    pub BgColor: ImU32,
    pub Column: ImGuiTableColumnIdx,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiTableHeaderData {
    pub Index: ImGuiTableColumnIdx,
    pub TextColor: ImU32,
    pub BgColor0: ImU32,
    pub BgColor1: ImU32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiTableInstanceData {
    pub TableInstanceID: ImGuiID,
    pub LastOuterHeight: f32,
    pub LastTopHeadersRowHeight: f32,
    pub LastFrozenHeight: f32,
    pub HoveredRowLast: ::core::ffi::c_int,
    pub HoveredRowNext: ::core::ffi::c_int,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImSpan_ImGuiTableColumn {
    pub Data: *mut ImGuiTableColumn,
    pub DataEnd: *mut ImGuiTableColumn,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImSpan_ImGuiTableColumnIdx {
    pub Data: *mut ImGuiTableColumnIdx,
    pub DataEnd: *mut ImGuiTableColumnIdx,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImSpan_ImGuiTableCellData {
    pub Data: *mut ImGuiTableCellData,
    pub DataEnd: *mut ImGuiTableCellData,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiTableInstanceData {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiTableInstanceData,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiTableColumnSortSpecs {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiTableColumnSortSpecs,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiTable {
    pub ID: ImGuiID,
    pub Flags: ImGuiTableFlags,
    pub RawData: *mut ::core::ffi::c_void,
    pub TempData: *mut ImGuiTableTempData,
    pub Columns: ImSpan_ImGuiTableColumn,
    pub DisplayOrderToIndex: ImSpan_ImGuiTableColumnIdx,
    pub RowCellData: ImSpan_ImGuiTableCellData,
    pub EnabledMaskByDisplayOrder: ImBitArrayPtr,
    pub EnabledMaskByIndex: ImBitArrayPtr,
    pub VisibleMaskByIndex: ImBitArrayPtr,
    pub SettingsLoadedFlags: ImGuiTableFlags,
    pub SettingsOffset: ::core::ffi::c_int,
    pub LastFrameActive: ::core::ffi::c_int,
    pub ColumnsCount: ::core::ffi::c_int,
    pub CurrentRow: ::core::ffi::c_int,
    pub CurrentColumn: ::core::ffi::c_int,
    pub InstanceCurrent: ImS16,
    pub InstanceInteracted: ImS16,
    pub RowPosY1: f32,
    pub RowPosY2: f32,
    pub RowMinHeight: f32,
    pub RowCellPaddingY: f32,
    pub RowTextBaseline: f32,
    pub RowIndentOffsetX: f32,
    pub _bitfield_align_1: [u16; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
    pub RowBgColorCounter: ::core::ffi::c_int,
    pub RowBgColor: [ImU32; 2usize],
    pub BorderColorStrong: ImU32,
    pub BorderColorLight: ImU32,
    pub BorderX1: f32,
    pub BorderX2: f32,
    pub HostIndentX: f32,
    pub MinColumnWidth: f32,
    pub OuterPaddingX: f32,
    pub CellPaddingX: f32,
    pub CellSpacingX1: f32,
    pub CellSpacingX2: f32,
    pub InnerWidth: f32,
    pub ColumnsGivenWidth: f32,
    pub ColumnsAutoFitWidth: f32,
    pub ColumnsStretchSumWeights: f32,
    pub ResizedColumnNextWidth: f32,
    pub ResizeLockMinContentsX2: f32,
    pub RefScale: f32,
    pub AngledHeadersHeight: f32,
    pub AngledHeadersSlope: f32,
    pub OuterRect: ImRect_c,
    pub InnerRect: ImRect_c,
    pub WorkRect: ImRect_c,
    pub InnerClipRect: ImRect_c,
    pub BgClipRect: ImRect_c,
    pub Bg0ClipRectForDrawCmd: ImRect_c,
    pub Bg2ClipRectForDrawCmd: ImRect_c,
    pub HostClipRect: ImRect_c,
    pub HostBackupInnerClipRect: ImRect_c,
    pub OuterWindow: *mut ImGuiWindow,
    pub InnerWindow: *mut ImGuiWindow,
    pub ColumnsNames: ImGuiTextBuffer,
    pub DrawSplitter: *mut ImDrawListSplitter,
    pub InstanceDataFirst: ImGuiTableInstanceData,
    pub InstanceDataExtra: ImVector_ImGuiTableInstanceData,
    pub SortSpecsSingle: ImGuiTableColumnSortSpecs,
    pub SortSpecsMulti: ImVector_ImGuiTableColumnSortSpecs,
    pub SortSpecs: ImGuiTableSortSpecs,
    pub SortSpecsCount: ImGuiTableColumnIdx,
    pub ColumnsEnabledCount: ImGuiTableColumnIdx,
    pub ColumnsEnabledFixedCount: ImGuiTableColumnIdx,
    pub DeclColumnsCount: ImGuiTableColumnIdx,
    pub AngledHeadersCount: ImGuiTableColumnIdx,
    pub HoveredColumnBody: ImGuiTableColumnIdx,
    pub HoveredColumnBorder: ImGuiTableColumnIdx,
    pub HighlightColumnHeader: ImGuiTableColumnIdx,
    pub AutoFitSingleColumn: ImGuiTableColumnIdx,
    pub ResizedColumn: ImGuiTableColumnIdx,
    pub LastResizedColumn: ImGuiTableColumnIdx,
    pub HeldHeaderColumn: ImGuiTableColumnIdx,
    pub LastHeldHeaderColumn: ImGuiTableColumnIdx,
    pub ReorderColumn: ImGuiTableColumnIdx,
    pub ReorderColumnDstOrder: ImGuiTableColumnIdx,
    pub LeftMostEnabledColumn: ImGuiTableColumnIdx,
    pub RightMostEnabledColumn: ImGuiTableColumnIdx,
    pub LeftMostStretchedColumn: ImGuiTableColumnIdx,
    pub RightMostStretchedColumn: ImGuiTableColumnIdx,
    pub ContextPopupColumn: ImGuiTableColumnIdx,
    pub FreezeRowsRequest: ImGuiTableColumnIdx,
    pub FreezeRowsCount: ImGuiTableColumnIdx,
    pub FreezeColumnsRequest: ImGuiTableColumnIdx,
    pub FreezeColumnsCount: ImGuiTableColumnIdx,
    pub RowCellDataCurrent: ImGuiTableColumnIdx,
    pub DummyDrawChannel: ImGuiTableDrawChannelIdx,
    pub Bg2DrawChannelCurrent: ImGuiTableDrawChannelIdx,
    pub Bg2DrawChannelUnfrozen: ImGuiTableDrawChannelIdx,
    pub NavLayer: ImS8,
    pub IsLayoutLocked: bool,
    pub IsInsideRow: bool,
    pub IsInitializing: bool,
    pub IsSortSpecsDirty: bool,
    pub IsUsingHeaders: bool,
    pub IsContextPopupOpen: bool,
    pub DisableDefaultContextMenu: bool,
    pub IsSettingsRequestLoad: bool,
    pub IsSettingsDirty: bool,
    pub IsDefaultDisplayOrder: bool,
    pub IsResetAllRequest: bool,
    pub IsResetDisplayOrderRequest: bool,
    pub IsUnfrozenRows: bool,
    pub IsDefaultSizingPolicy: bool,
    pub IsActiveIdAliveBeforeTable: bool,
    pub IsActiveIdInTable: bool,
    pub HasScrollbarYCurr: bool,
    pub HasScrollbarYPrev: bool,
    pub MemoryCompacted: bool,
    pub HostSkipItems: bool,
}
impl ImGuiTable {
    #[inline]
    pub fn RowFlags(&self) -> ImGuiTableRowFlags {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) }
    }
    #[inline]
    pub fn set_RowFlags(&mut self, val: ImGuiTableRowFlags) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(0usize, 16u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn RowFlags_raw(this: *const Self) -> ImGuiTableRowFlags {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                0usize,
                16u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_RowFlags_raw(this: *mut Self, val: ImGuiTableRowFlags) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                16u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn LastRowFlags(&self) -> ImGuiTableRowFlags {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
    }
    #[inline]
    pub fn set_LastRowFlags(&mut self, val: ImGuiTableRowFlags) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(16usize, 16u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn LastRowFlags_raw(this: *const Self) -> ImGuiTableRowFlags {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                16usize,
                16u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_LastRowFlags_raw(this: *mut Self, val: ImGuiTableRowFlags) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                16usize,
                16u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(RowFlags: ImGuiTableRowFlags, LastRowFlags: ImGuiTableRowFlags) -> __BindgenBitfieldUnit<[u8; 4usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 16u8, {
            let RowFlags: u32 = unsafe { ::core::mem::transmute(RowFlags) };
            RowFlags as u64
        });
        __bindgen_bitfield_unit.set(16usize, 16u8, {
            let LastRowFlags: u32 = unsafe { ::core::mem::transmute(LastRowFlags) };
            LastRowFlags as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImGuiTableHeaderData {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImGuiTableHeaderData,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiTableTempData {
    pub WindowID: ImGuiID,
    pub TableIndex: ::core::ffi::c_int,
    pub LastTimeActive: f32,
    pub AngledHeadersExtraWidth: f32,
    pub AngledHeadersRequests: ImVector_ImGuiTableHeaderData,
    pub UserOuterSize: ImVec2_c,
    pub DrawSplitter: ImDrawListSplitter,
    pub HostBackupWorkRect: ImRect_c,
    pub HostBackupParentWorkRect: ImRect_c,
    pub HostBackupPrevLineSize: ImVec2_c,
    pub HostBackupCurrLineSize: ImVec2_c,
    pub HostBackupCursorMaxPos: ImVec2_c,
    pub HostBackupColumnsOffset: ImVec1,
    pub HostBackupItemWidth: f32,
    pub HostBackupItemWidthStackSize: ::core::ffi::c_int,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiTableColumnSettings {
    pub WidthOrWeight: f32,
    pub UserID: ImGuiID,
    pub Index: ImGuiTableColumnIdx,
    pub DisplayOrder: ImGuiTableColumnIdx,
    pub SortOrder: ImGuiTableColumnIdx,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
    pub __bindgen_padding_0: u8,
}
impl ImGuiTableColumnSettings {
    #[inline]
    pub fn SortDirection(&self) -> ImU8 {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u8) }
    }
    #[inline]
    pub fn set_SortDirection(&mut self, val: ImU8) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            self._bitfield_1.set(0usize, 2u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn SortDirection_raw(this: *const Self) -> ImU8 {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                0usize,
                2u8,
            ) as u8)
        }
    }
    #[inline]
    pub unsafe fn set_SortDirection_raw(this: *mut Self, val: ImU8) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                2u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn IsEnabled(&self) -> ImS8 {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u8) }
    }
    #[inline]
    pub fn set_IsEnabled(&mut self, val: ImS8) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            self._bitfield_1.set(2usize, 2u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn IsEnabled_raw(this: *const Self) -> ImS8 {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                2usize,
                2u8,
            ) as u8)
        }
    }
    #[inline]
    pub unsafe fn set_IsEnabled_raw(this: *mut Self, val: ImS8) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                2usize,
                2u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn IsStretch(&self) -> ImU8 {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_IsStretch(&mut self, val: ImU8) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            self._bitfield_1.set(4usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn IsStretch_raw(this: *const Self) -> ImU8 {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                4usize,
                1u8,
            ) as u8)
        }
    }
    #[inline]
    pub unsafe fn set_IsStretch_raw(this: *mut Self, val: ImU8) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                4usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(SortDirection: ImU8, IsEnabled: ImS8, IsStretch: ImU8) -> __BindgenBitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 2u8, {
            let SortDirection: u8 = unsafe { ::core::mem::transmute(SortDirection) };
            SortDirection as u64
        });
        __bindgen_bitfield_unit.set(2usize, 2u8, {
            let IsEnabled: u8 = unsafe { ::core::mem::transmute(IsEnabled) };
            IsEnabled as u64
        });
        __bindgen_bitfield_unit.set(4usize, 1u8, {
            let IsStretch: u8 = unsafe { ::core::mem::transmute(IsStretch) };
            IsStretch as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImGuiTableSettings {
    pub ID: ImGuiID,
    pub SaveFlags: ImGuiTableFlags,
    pub RefScale: f32,
    pub ColumnsCount: ImGuiTableColumnIdx,
    pub ColumnsCountMax: ImGuiTableColumnIdx,
    pub WantApply: bool,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImFontLoader {
    pub Name: *const ::core::ffi::c_char,
    pub LoaderInit: ::core::option::Option<unsafe extern "C" fn(atlas: *mut ImFontAtlas) -> bool>,
    pub LoaderShutdown: ::core::option::Option<unsafe extern "C" fn(atlas: *mut ImFontAtlas)>,
    pub FontSrcInit: ::core::option::Option<unsafe extern "C" fn(atlas: *mut ImFontAtlas, src: *mut ImFontConfig) -> bool>,
    pub FontSrcDestroy: ::core::option::Option<unsafe extern "C" fn(atlas: *mut ImFontAtlas, src: *mut ImFontConfig)>,
    pub FontSrcContainsGlyph:
        ::core::option::Option<unsafe extern "C" fn(atlas: *mut ImFontAtlas, src: *mut ImFontConfig, codepoint: ImWchar) -> bool>,
    pub FontBakedInit: ::core::option::Option<
        unsafe extern "C" fn(
            atlas: *mut ImFontAtlas,
            src: *mut ImFontConfig,
            baked: *mut ImFontBaked,
            loader_data_for_baked_src: *mut ::core::ffi::c_void,
        ) -> bool,
    >,
    pub FontBakedDestroy: ::core::option::Option<
        unsafe extern "C" fn(
            atlas: *mut ImFontAtlas,
            src: *mut ImFontConfig,
            baked: *mut ImFontBaked,
            loader_data_for_baked_src: *mut ::core::ffi::c_void,
        ),
    >,
    pub FontBakedLoadGlyph: ::core::option::Option<
        unsafe extern "C" fn(
            atlas: *mut ImFontAtlas,
            src: *mut ImFontConfig,
            baked: *mut ImFontBaked,
            loader_data_for_baked_src: *mut ::core::ffi::c_void,
            codepoint: ImWchar,
            out_glyph: *mut ImFontGlyph,
            out_advance_x: *mut f32,
        ) -> bool,
    >,
    pub FontBakedSrcLoaderDataSize: usize,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImFontAtlasRectEntry {
    pub _bitfield_align_1: [u32; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
}
impl ImFontAtlasRectEntry {
    #[inline]
    pub fn TargetIndex(&self) -> ::core::ffi::c_int {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 20u8) as u32) }
    }
    #[inline]
    pub fn set_TargetIndex(&mut self, val: ::core::ffi::c_int) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(0usize, 20u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn TargetIndex_raw(this: *const Self) -> ::core::ffi::c_int {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                0usize,
                20u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_TargetIndex_raw(this: *mut Self, val: ::core::ffi::c_int) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                20u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn Generation(&self) -> ::core::ffi::c_uint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(20usize, 10u8) as u32) }
    }
    #[inline]
    pub fn set_Generation(&mut self, val: ::core::ffi::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(20usize, 10u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn Generation_raw(this: *const Self) -> ::core::ffi::c_uint {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                20usize,
                10u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_Generation_raw(this: *mut Self, val: ::core::ffi::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                20usize,
                10u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn IsUsed(&self) -> ::core::ffi::c_uint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_IsUsed(&mut self, val: ::core::ffi::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(30usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn IsUsed_raw(this: *const Self) -> ::core::ffi::c_uint {
        unsafe {
            ::core::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
                ::core::ptr::addr_of!((*this)._bitfield_1),
                30usize,
                1u8,
            ) as u32)
        }
    }
    #[inline]
    pub unsafe fn set_IsUsed_raw(this: *mut Self, val: ::core::ffi::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
                ::core::ptr::addr_of_mut!((*this)._bitfield_1),
                30usize,
                1u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        TargetIndex: ::core::ffi::c_int,
        Generation: ::core::ffi::c_uint,
        IsUsed: ::core::ffi::c_uint,
    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 20u8, {
            let TargetIndex: u32 = unsafe { ::core::mem::transmute(TargetIndex) };
            TargetIndex as u64
        });
        __bindgen_bitfield_unit.set(20usize, 10u8, {
            let Generation: u32 = unsafe { ::core::mem::transmute(Generation) };
            Generation as u64
        });
        __bindgen_bitfield_unit.set(30usize, 1u8, {
            let IsUsed: u32 = unsafe { ::core::mem::transmute(IsUsed) };
            IsUsed as u64
        });
        __bindgen_bitfield_unit
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImFontAtlasPostProcessData {
    pub FontAtlas: *mut ImFontAtlas,
    pub Font: *mut ImFont,
    pub FontSrc: *mut ImFontConfig,
    pub FontBaked: *mut ImFontBaked,
    pub Glyph: *mut ImFontGlyph,
    pub Pixels: *mut ::core::ffi::c_void,
    pub Format: ImTextureFormat,
    pub Pitch: ::core::ffi::c_int,
    pub Width: ::core::ffi::c_int,
    pub Height: ::core::ffi::c_int,
}
pub type stbrp_node_im = stbrp_node;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct stbrp_context_opaque {
    pub data: [::core::ffi::c_char; 80usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_stbrp_node_im {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut stbrp_node_im,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImFontAtlasRectEntry {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut ImFontAtlasRectEntry,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImVector_ImFontBakedPtr {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Data: *mut *mut ImFontBaked,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImStableVector_ImFontBaked__32 {
    pub Size: ::core::ffi::c_int,
    pub Capacity: ::core::ffi::c_int,
    pub Blocks: ImVector_ImFontBakedPtr,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ImFontAtlasBuilder {
    pub PackContext: stbrp_context_opaque,
    pub PackNodes: ImVector_stbrp_node_im,
    pub Rects: ImVector_ImTextureRect,
    pub RectsIndex: ImVector_ImFontAtlasRectEntry,
    pub TempBuffer: ImVector_unsigned_char,
    pub RectsIndexFreeListStart: ::core::ffi::c_int,
    pub RectsPackedCount: ::core::ffi::c_int,
    pub RectsPackedSurface: ::core::ffi::c_int,
    pub RectsDiscardedCount: ::core::ffi::c_int,
    pub RectsDiscardedSurface: ::core::ffi::c_int,
    pub FrameCount: ::core::ffi::c_int,
    pub MaxRectSize: ImVec2i_c,
    pub MaxRectBounds: ImVec2i_c,
    pub LockDisableResize: bool,
    pub PreloadedAllGlyphsRanges: bool,
    pub BakedPool: ImStableVector_ImFontBaked__32,
    pub BakedMap: ImGuiStorage,
    pub BakedDiscardedCount: ::core::ffi::c_int,
    pub PackIdMouseCursors: ImFontAtlasRectId,
    pub PackIdLinesTexData: ImFontAtlasRectId,
}
pub type ImTextureRef = ImTextureRef_c;
pub type ImVec2 = ImVec2_c;
pub type ImVec2i = ImVec2i_c;
pub type ImVec4 = ImVec4_c;
pub type ImColor = ImColor_c;
pub type ImRect = ImRect_c;
unsafe extern "C" {
    pub fn ImVec2_ImVec2_Nil() -> *mut ImVec2;
    pub fn ImVec2_destroy(self_: *mut ImVec2);
    pub fn ImVec2_ImVec2_Float(_x: f32, _y: f32) -> *mut ImVec2;
    pub fn ImVec4_ImVec4_Nil() -> *mut ImVec4;
    pub fn ImVec4_destroy(self_: *mut ImVec4);
    pub fn ImVec4_ImVec4_Float(_x: f32, _y: f32, _z: f32, _w: f32) -> *mut ImVec4;
    pub fn ImTextureRef_ImTextureRef_Nil() -> *mut ImTextureRef;
    pub fn ImTextureRef_destroy(self_: *mut ImTextureRef);
    pub fn ImTextureRef_ImTextureRef_TextureID(tex_id: ImTextureID) -> *mut ImTextureRef;
    pub fn ImTextureRef_GetTexID(self_: *mut ImTextureRef) -> ImTextureID;
    pub fn igCreateContext(shared_font_atlas: *mut ImFontAtlas) -> *mut ImGuiContext;
    pub fn igDestroyContext(ctx: *mut ImGuiContext);
    pub fn igGetCurrentContext() -> *mut ImGuiContext;
    pub fn igSetCurrentContext(ctx: *mut ImGuiContext);
    pub fn igGetIO_Nil() -> *mut ImGuiIO;
    pub fn igGetPlatformIO_Nil() -> *mut ImGuiPlatformIO;
    pub fn igGetStyle() -> *mut ImGuiStyle;
    pub fn igNewFrame();
    pub fn igEndFrame();
    pub fn igRender();
    pub fn igGetDrawData() -> *mut ImDrawData;
    pub fn igShowDemoWindow(p_open: *mut bool);
    pub fn igShowMetricsWindow(p_open: *mut bool);
    pub fn igShowDebugLogWindow(p_open: *mut bool);
    pub fn igShowIDStackToolWindow(p_open: *mut bool);
    pub fn igShowAboutWindow(p_open: *mut bool);
    pub fn igShowStyleEditor(ref_: *mut ImGuiStyle);
    pub fn igShowStyleSelector(label: *const ::core::ffi::c_char) -> bool;
    pub fn igShowFontSelector(label: *const ::core::ffi::c_char);
    pub fn igShowUserGuide();
    pub fn igGetVersion() -> *const ::core::ffi::c_char;
    pub fn igStyleColorsDark(dst: *mut ImGuiStyle);
    pub fn igStyleColorsLight(dst: *mut ImGuiStyle);
    pub fn igStyleColorsClassic(dst: *mut ImGuiStyle);
    pub fn igBegin(name: *const ::core::ffi::c_char, p_open: *mut bool, flags: ImGuiWindowFlags) -> bool;
    pub fn igEnd();
    pub fn igBeginChild_Str(
        str_id: *const ::core::ffi::c_char,
        size: ImVec2_c,
        child_flags: ImGuiChildFlags,
        window_flags: ImGuiWindowFlags,
    ) -> bool;
    pub fn igBeginChild_ID(id: ImGuiID, size: ImVec2_c, child_flags: ImGuiChildFlags, window_flags: ImGuiWindowFlags) -> bool;
    pub fn igEndChild();
    pub fn igIsWindowAppearing() -> bool;
    pub fn igIsWindowCollapsed() -> bool;
    pub fn igIsWindowFocused(flags: ImGuiFocusedFlags) -> bool;
    pub fn igIsWindowHovered(flags: ImGuiHoveredFlags) -> bool;
    pub fn igGetWindowDrawList() -> *mut ImDrawList;
    pub fn igGetWindowPos() -> ImVec2_c;
    pub fn igGetWindowSize() -> ImVec2_c;
    pub fn igGetWindowWidth() -> f32;
    pub fn igGetWindowHeight() -> f32;
    pub fn igSetNextWindowPos(pos: ImVec2_c, cond: ImGuiCond, pivot: ImVec2_c);
    pub fn igSetNextWindowSize(size: ImVec2_c, cond: ImGuiCond);
    pub fn igSetNextWindowSizeConstraints(
        size_min: ImVec2_c,
        size_max: ImVec2_c,
        custom_callback: ImGuiSizeCallback,
        custom_callback_data: *mut ::core::ffi::c_void,
    );
    pub fn igSetNextWindowContentSize(size: ImVec2_c);
    pub fn igSetNextWindowCollapsed(collapsed: bool, cond: ImGuiCond);
    pub fn igSetNextWindowFocus();
    pub fn igSetNextWindowScroll(scroll: ImVec2_c);
    pub fn igSetNextWindowBgAlpha(alpha: f32);
    pub fn igSetWindowPos_Vec2(pos: ImVec2_c, cond: ImGuiCond);
    pub fn igSetWindowSize_Vec2(size: ImVec2_c, cond: ImGuiCond);
    pub fn igSetWindowCollapsed_Bool(collapsed: bool, cond: ImGuiCond);
    pub fn igSetWindowFocus_Nil();
    pub fn igSetWindowPos_Str(name: *const ::core::ffi::c_char, pos: ImVec2_c, cond: ImGuiCond);
    pub fn igSetWindowSize_Str(name: *const ::core::ffi::c_char, size: ImVec2_c, cond: ImGuiCond);
    pub fn igSetWindowCollapsed_Str(name: *const ::core::ffi::c_char, collapsed: bool, cond: ImGuiCond);
    pub fn igSetWindowFocus_Str(name: *const ::core::ffi::c_char);
    pub fn igGetScrollX() -> f32;
    pub fn igGetScrollY() -> f32;
    pub fn igSetScrollX_Float(scroll_x: f32);
    pub fn igSetScrollY_Float(scroll_y: f32);
    pub fn igGetScrollMaxX() -> f32;
    pub fn igGetScrollMaxY() -> f32;
    pub fn igSetScrollHereX(center_x_ratio: f32);
    pub fn igSetScrollHereY(center_y_ratio: f32);
    pub fn igSetScrollFromPosX_Float(local_x: f32, center_x_ratio: f32);
    pub fn igSetScrollFromPosY_Float(local_y: f32, center_y_ratio: f32);
    pub fn igPushFont(font: *mut ImFont, font_size_base_unscaled: f32);
    pub fn igPopFont();
    pub fn igGetFont() -> *mut ImFont;
    pub fn igGetFontSize() -> f32;
    pub fn igGetFontBaked() -> *mut ImFontBaked;
    pub fn igPushStyleColor_U32(idx: ImGuiCol, col: ImU32);
    pub fn igPushStyleColor_Vec4(idx: ImGuiCol, col: ImVec4_c);
    pub fn igPopStyleColor(count: ::core::ffi::c_int);
    pub fn igPushStyleVar_Float(idx: ImGuiStyleVar, val: f32);
    pub fn igPushStyleVar_Vec2(idx: ImGuiStyleVar, val: ImVec2_c);
    pub fn igPushStyleVarX(idx: ImGuiStyleVar, val_x: f32);
    pub fn igPushStyleVarY(idx: ImGuiStyleVar, val_y: f32);
    pub fn igPopStyleVar(count: ::core::ffi::c_int);
    pub fn igPushItemFlag(option: ImGuiItemFlags, enabled: bool);
    pub fn igPopItemFlag();
    pub fn igPushItemWidth(item_width: f32);
    pub fn igPopItemWidth();
    pub fn igSetNextItemWidth(item_width: f32);
    pub fn igCalcItemWidth() -> f32;
    pub fn igPushTextWrapPos(wrap_local_pos_x: f32);
    pub fn igPopTextWrapPos();
    pub fn igGetFontTexUvWhitePixel() -> ImVec2_c;
    pub fn igGetColorU32_Col(idx: ImGuiCol, alpha_mul: f32) -> ImU32;
    pub fn igGetColorU32_Vec4(col: ImVec4_c) -> ImU32;
    pub fn igGetColorU32_U32(col: ImU32, alpha_mul: f32) -> ImU32;
    pub fn igGetStyleColorVec4(idx: ImGuiCol) -> *const ImVec4_c;
    pub fn igGetCursorScreenPos() -> ImVec2_c;
    pub fn igSetCursorScreenPos(pos: ImVec2_c);
    pub fn igGetContentRegionAvail() -> ImVec2_c;
    pub fn igGetCursorPos() -> ImVec2_c;
    pub fn igGetCursorPosX() -> f32;
    pub fn igGetCursorPosY() -> f32;
    pub fn igSetCursorPos(local_pos: ImVec2_c);
    pub fn igSetCursorPosX(local_x: f32);
    pub fn igSetCursorPosY(local_y: f32);
    pub fn igGetCursorStartPos() -> ImVec2_c;
    pub fn igSeparator();
    pub fn igSameLine(offset_from_start_x: f32, spacing: f32);
    pub fn igNewLine();
    pub fn igSpacing();
    pub fn igDummy(size: ImVec2_c);
    pub fn igIndent(indent_w: f32);
    pub fn igUnindent(indent_w: f32);
    pub fn igBeginGroup();
    pub fn igEndGroup();
    pub fn igAlignTextToFramePadding();
    pub fn igGetTextLineHeight() -> f32;
    pub fn igGetTextLineHeightWithSpacing() -> f32;
    pub fn igGetFrameHeight() -> f32;
    pub fn igGetFrameHeightWithSpacing() -> f32;
    pub fn igPushID_Str(str_id: *const ::core::ffi::c_char);
    pub fn igPushID_StrStr(str_id_begin: *const ::core::ffi::c_char, str_id_end: *const ::core::ffi::c_char);
    pub fn igPushID_Ptr(ptr_id: *const ::core::ffi::c_void);
    pub fn igPushID_Int(int_id: ::core::ffi::c_int);
    pub fn igPopID();
    pub fn igGetID_Str(str_id: *const ::core::ffi::c_char) -> ImGuiID;
    pub fn igGetID_StrStr(str_id_begin: *const ::core::ffi::c_char, str_id_end: *const ::core::ffi::c_char) -> ImGuiID;
    pub fn igGetID_Ptr(ptr_id: *const ::core::ffi::c_void) -> ImGuiID;
    pub fn igGetID_Int(int_id: ::core::ffi::c_int) -> ImGuiID;
    pub fn igTextUnformatted(text: *const ::core::ffi::c_char, text_end: *const ::core::ffi::c_char);
    pub fn igText(fmt: *const ::core::ffi::c_char, ...);
    pub fn igTextV(fmt: *const ::core::ffi::c_char, args: va_list);
    pub fn igTextColored(col: ImVec4_c, fmt: *const ::core::ffi::c_char, ...);
    pub fn igTextColoredV(col: ImVec4_c, fmt: *const ::core::ffi::c_char, args: va_list);
    pub fn igTextDisabled(fmt: *const ::core::ffi::c_char, ...);
    pub fn igTextDisabledV(fmt: *const ::core::ffi::c_char, args: va_list);
    pub fn igTextWrapped(fmt: *const ::core::ffi::c_char, ...);
    pub fn igTextWrappedV(fmt: *const ::core::ffi::c_char, args: va_list);
    pub fn igLabelText(label: *const ::core::ffi::c_char, fmt: *const ::core::ffi::c_char, ...);
    pub fn igLabelTextV(label: *const ::core::ffi::c_char, fmt: *const ::core::ffi::c_char, args: va_list);
    pub fn igBulletText(fmt: *const ::core::ffi::c_char, ...);
    pub fn igBulletTextV(fmt: *const ::core::ffi::c_char, args: va_list);
    pub fn igSeparatorText(label: *const ::core::ffi::c_char);
    pub fn igButton(label: *const ::core::ffi::c_char, size: ImVec2_c) -> bool;
    pub fn igSmallButton(label: *const ::core::ffi::c_char) -> bool;
    pub fn igInvisibleButton(str_id: *const ::core::ffi::c_char, size: ImVec2_c, flags: ImGuiButtonFlags) -> bool;
    pub fn igArrowButton(str_id: *const ::core::ffi::c_char, dir: ImGuiDir) -> bool;
    pub fn igCheckbox(label: *const ::core::ffi::c_char, v: *mut bool) -> bool;
    pub fn igCheckboxFlags_IntPtr(
        label: *const ::core::ffi::c_char,
        flags: *mut ::core::ffi::c_int,
        flags_value: ::core::ffi::c_int,
    ) -> bool;
    pub fn igCheckboxFlags_UintPtr(
        label: *const ::core::ffi::c_char,
        flags: *mut ::core::ffi::c_uint,
        flags_value: ::core::ffi::c_uint,
    ) -> bool;
    pub fn igRadioButton_Bool(label: *const ::core::ffi::c_char, active: bool) -> bool;
    pub fn igRadioButton_IntPtr(
        label: *const ::core::ffi::c_char,
        v: *mut ::core::ffi::c_int,
        v_button: ::core::ffi::c_int,
    ) -> bool;
    pub fn igProgressBar(fraction: f32, size_arg: ImVec2_c, overlay: *const ::core::ffi::c_char);
    pub fn igBullet();
    pub fn igTextLink(label: *const ::core::ffi::c_char) -> bool;
    pub fn igTextLinkOpenURL(label: *const ::core::ffi::c_char, url: *const ::core::ffi::c_char) -> bool;
    pub fn igImage(tex_ref: ImTextureRef_c, image_size: ImVec2_c, uv0: ImVec2_c, uv1: ImVec2_c);
    pub fn igImageWithBg(
        tex_ref: ImTextureRef_c,
        image_size: ImVec2_c,
        uv0: ImVec2_c,
        uv1: ImVec2_c,
        bg_col: ImVec4_c,
        tint_col: ImVec4_c,
    );
    pub fn igImageButton(
        str_id: *const ::core::ffi::c_char,
        tex_ref: ImTextureRef_c,
        image_size: ImVec2_c,
        uv0: ImVec2_c,
        uv1: ImVec2_c,
        bg_col: ImVec4_c,
        tint_col: ImVec4_c,
    ) -> bool;
    pub fn igBeginCombo(
        label: *const ::core::ffi::c_char,
        preview_value: *const ::core::ffi::c_char,
        flags: ImGuiComboFlags,
    ) -> bool;
    pub fn igEndCombo();
    pub fn igCombo_Str_arr(
        label: *const ::core::ffi::c_char,
        current_item: *mut ::core::ffi::c_int,
        items: *const *const ::core::ffi::c_char,
        items_count: ::core::ffi::c_int,
        popup_max_height_in_items: ::core::ffi::c_int,
    ) -> bool;
    pub fn igCombo_Str(
        label: *const ::core::ffi::c_char,
        current_item: *mut ::core::ffi::c_int,
        items_separated_by_zeros: *const ::core::ffi::c_char,
        popup_max_height_in_items: ::core::ffi::c_int,
    ) -> bool;
    pub fn igCombo_FnStrPtr(
        label: *const ::core::ffi::c_char,
        current_item: *mut ::core::ffi::c_int,
        getter: ::core::option::Option<
            unsafe extern "C" fn(user_data: *mut ::core::ffi::c_void, idx: ::core::ffi::c_int) -> *const ::core::ffi::c_char,
        >,
        user_data: *mut ::core::ffi::c_void,
        items_count: ::core::ffi::c_int,
        popup_max_height_in_items: ::core::ffi::c_int,
    ) -> bool;
    pub fn igDragFloat(
        label: *const ::core::ffi::c_char,
        v: *mut f32,
        v_speed: f32,
        v_min: f32,
        v_max: f32,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igDragFloat2(
        label: *const ::core::ffi::c_char,
        v: *mut f32,
        v_speed: f32,
        v_min: f32,
        v_max: f32,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igDragFloat3(
        label: *const ::core::ffi::c_char,
        v: *mut f32,
        v_speed: f32,
        v_min: f32,
        v_max: f32,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igDragFloat4(
        label: *const ::core::ffi::c_char,
        v: *mut f32,
        v_speed: f32,
        v_min: f32,
        v_max: f32,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igDragFloatRange2(
        label: *const ::core::ffi::c_char,
        v_current_min: *mut f32,
        v_current_max: *mut f32,
        v_speed: f32,
        v_min: f32,
        v_max: f32,
        format: *const ::core::ffi::c_char,
        format_max: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igDragInt(
        label: *const ::core::ffi::c_char,
        v: *mut ::core::ffi::c_int,
        v_speed: f32,
        v_min: ::core::ffi::c_int,
        v_max: ::core::ffi::c_int,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igDragInt2(
        label: *const ::core::ffi::c_char,
        v: *mut ::core::ffi::c_int,
        v_speed: f32,
        v_min: ::core::ffi::c_int,
        v_max: ::core::ffi::c_int,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igDragInt3(
        label: *const ::core::ffi::c_char,
        v: *mut ::core::ffi::c_int,
        v_speed: f32,
        v_min: ::core::ffi::c_int,
        v_max: ::core::ffi::c_int,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igDragInt4(
        label: *const ::core::ffi::c_char,
        v: *mut ::core::ffi::c_int,
        v_speed: f32,
        v_min: ::core::ffi::c_int,
        v_max: ::core::ffi::c_int,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igDragIntRange2(
        label: *const ::core::ffi::c_char,
        v_current_min: *mut ::core::ffi::c_int,
        v_current_max: *mut ::core::ffi::c_int,
        v_speed: f32,
        v_min: ::core::ffi::c_int,
        v_max: ::core::ffi::c_int,
        format: *const ::core::ffi::c_char,
        format_max: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igDragScalar(
        label: *const ::core::ffi::c_char,
        data_type: ImGuiDataType,
        p_data: *mut ::core::ffi::c_void,
        v_speed: f32,
        p_min: *const ::core::ffi::c_void,
        p_max: *const ::core::ffi::c_void,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igDragScalarN(
        label: *const ::core::ffi::c_char,
        data_type: ImGuiDataType,
        p_data: *mut ::core::ffi::c_void,
        components: ::core::ffi::c_int,
        v_speed: f32,
        p_min: *const ::core::ffi::c_void,
        p_max: *const ::core::ffi::c_void,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igSliderFloat(
        label: *const ::core::ffi::c_char,
        v: *mut f32,
        v_min: f32,
        v_max: f32,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igSliderFloat2(
        label: *const ::core::ffi::c_char,
        v: *mut f32,
        v_min: f32,
        v_max: f32,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igSliderFloat3(
        label: *const ::core::ffi::c_char,
        v: *mut f32,
        v_min: f32,
        v_max: f32,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igSliderFloat4(
        label: *const ::core::ffi::c_char,
        v: *mut f32,
        v_min: f32,
        v_max: f32,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igSliderAngle(
        label: *const ::core::ffi::c_char,
        v_rad: *mut f32,
        v_degrees_min: f32,
        v_degrees_max: f32,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igSliderInt(
        label: *const ::core::ffi::c_char,
        v: *mut ::core::ffi::c_int,
        v_min: ::core::ffi::c_int,
        v_max: ::core::ffi::c_int,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igSliderInt2(
        label: *const ::core::ffi::c_char,
        v: *mut ::core::ffi::c_int,
        v_min: ::core::ffi::c_int,
        v_max: ::core::ffi::c_int,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igSliderInt3(
        label: *const ::core::ffi::c_char,
        v: *mut ::core::ffi::c_int,
        v_min: ::core::ffi::c_int,
        v_max: ::core::ffi::c_int,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igSliderInt4(
        label: *const ::core::ffi::c_char,
        v: *mut ::core::ffi::c_int,
        v_min: ::core::ffi::c_int,
        v_max: ::core::ffi::c_int,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igSliderScalar(
        label: *const ::core::ffi::c_char,
        data_type: ImGuiDataType,
        p_data: *mut ::core::ffi::c_void,
        p_min: *const ::core::ffi::c_void,
        p_max: *const ::core::ffi::c_void,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igSliderScalarN(
        label: *const ::core::ffi::c_char,
        data_type: ImGuiDataType,
        p_data: *mut ::core::ffi::c_void,
        components: ::core::ffi::c_int,
        p_min: *const ::core::ffi::c_void,
        p_max: *const ::core::ffi::c_void,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igVSliderFloat(
        label: *const ::core::ffi::c_char,
        size: ImVec2_c,
        v: *mut f32,
        v_min: f32,
        v_max: f32,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igVSliderInt(
        label: *const ::core::ffi::c_char,
        size: ImVec2_c,
        v: *mut ::core::ffi::c_int,
        v_min: ::core::ffi::c_int,
        v_max: ::core::ffi::c_int,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igVSliderScalar(
        label: *const ::core::ffi::c_char,
        size: ImVec2_c,
        data_type: ImGuiDataType,
        p_data: *mut ::core::ffi::c_void,
        p_min: *const ::core::ffi::c_void,
        p_max: *const ::core::ffi::c_void,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igInputText(
        label: *const ::core::ffi::c_char,
        buf: *mut ::core::ffi::c_char,
        buf_size: usize,
        flags: ImGuiInputTextFlags,
        callback: ImGuiInputTextCallback,
        user_data: *mut ::core::ffi::c_void,
    ) -> bool;
    pub fn igInputTextMultiline(
        label: *const ::core::ffi::c_char,
        buf: *mut ::core::ffi::c_char,
        buf_size: usize,
        size: ImVec2_c,
        flags: ImGuiInputTextFlags,
        callback: ImGuiInputTextCallback,
        user_data: *mut ::core::ffi::c_void,
    ) -> bool;
    pub fn igInputTextWithHint(
        label: *const ::core::ffi::c_char,
        hint: *const ::core::ffi::c_char,
        buf: *mut ::core::ffi::c_char,
        buf_size: usize,
        flags: ImGuiInputTextFlags,
        callback: ImGuiInputTextCallback,
        user_data: *mut ::core::ffi::c_void,
    ) -> bool;
    pub fn igInputFloat(
        label: *const ::core::ffi::c_char,
        v: *mut f32,
        step: f32,
        step_fast: f32,
        format: *const ::core::ffi::c_char,
        flags: ImGuiInputTextFlags,
    ) -> bool;
    pub fn igInputFloat2(
        label: *const ::core::ffi::c_char,
        v: *mut f32,
        format: *const ::core::ffi::c_char,
        flags: ImGuiInputTextFlags,
    ) -> bool;
    pub fn igInputFloat3(
        label: *const ::core::ffi::c_char,
        v: *mut f32,
        format: *const ::core::ffi::c_char,
        flags: ImGuiInputTextFlags,
    ) -> bool;
    pub fn igInputFloat4(
        label: *const ::core::ffi::c_char,
        v: *mut f32,
        format: *const ::core::ffi::c_char,
        flags: ImGuiInputTextFlags,
    ) -> bool;
    pub fn igInputInt(
        label: *const ::core::ffi::c_char,
        v: *mut ::core::ffi::c_int,
        step: ::core::ffi::c_int,
        step_fast: ::core::ffi::c_int,
        flags: ImGuiInputTextFlags,
    ) -> bool;
    pub fn igInputInt2(label: *const ::core::ffi::c_char, v: *mut ::core::ffi::c_int, flags: ImGuiInputTextFlags) -> bool;
    pub fn igInputInt3(label: *const ::core::ffi::c_char, v: *mut ::core::ffi::c_int, flags: ImGuiInputTextFlags) -> bool;
    pub fn igInputInt4(label: *const ::core::ffi::c_char, v: *mut ::core::ffi::c_int, flags: ImGuiInputTextFlags) -> bool;
    pub fn igInputDouble(
        label: *const ::core::ffi::c_char,
        v: *mut f64,
        step: f64,
        step_fast: f64,
        format: *const ::core::ffi::c_char,
        flags: ImGuiInputTextFlags,
    ) -> bool;
    pub fn igInputScalar(
        label: *const ::core::ffi::c_char,
        data_type: ImGuiDataType,
        p_data: *mut ::core::ffi::c_void,
        p_step: *const ::core::ffi::c_void,
        p_step_fast: *const ::core::ffi::c_void,
        format: *const ::core::ffi::c_char,
        flags: ImGuiInputTextFlags,
    ) -> bool;
    pub fn igInputScalarN(
        label: *const ::core::ffi::c_char,
        data_type: ImGuiDataType,
        p_data: *mut ::core::ffi::c_void,
        components: ::core::ffi::c_int,
        p_step: *const ::core::ffi::c_void,
        p_step_fast: *const ::core::ffi::c_void,
        format: *const ::core::ffi::c_char,
        flags: ImGuiInputTextFlags,
    ) -> bool;
    pub fn igColorEdit3(label: *const ::core::ffi::c_char, col: *mut f32, flags: ImGuiColorEditFlags) -> bool;
    pub fn igColorEdit4(label: *const ::core::ffi::c_char, col: *mut f32, flags: ImGuiColorEditFlags) -> bool;
    pub fn igColorPicker3(label: *const ::core::ffi::c_char, col: *mut f32, flags: ImGuiColorEditFlags) -> bool;
    pub fn igColorPicker4(
        label: *const ::core::ffi::c_char,
        col: *mut f32,
        flags: ImGuiColorEditFlags,
        ref_col: *const f32,
    ) -> bool;
    pub fn igColorButton(desc_id: *const ::core::ffi::c_char, col: ImVec4_c, flags: ImGuiColorEditFlags, size: ImVec2_c) -> bool;
    pub fn igSetColorEditOptions(flags: ImGuiColorEditFlags);
    pub fn igTreeNode_Str(label: *const ::core::ffi::c_char) -> bool;
    pub fn igTreeNode_StrStr(str_id: *const ::core::ffi::c_char, fmt: *const ::core::ffi::c_char, ...) -> bool;
    pub fn igTreeNode_Ptr(ptr_id: *const ::core::ffi::c_void, fmt: *const ::core::ffi::c_char, ...) -> bool;
    pub fn igTreeNodeV_Str(str_id: *const ::core::ffi::c_char, fmt: *const ::core::ffi::c_char, args: va_list) -> bool;
    pub fn igTreeNodeV_Ptr(ptr_id: *const ::core::ffi::c_void, fmt: *const ::core::ffi::c_char, args: va_list) -> bool;
    pub fn igTreeNodeEx_Str(label: *const ::core::ffi::c_char, flags: ImGuiTreeNodeFlags) -> bool;
    pub fn igTreeNodeEx_StrStr(
        str_id: *const ::core::ffi::c_char,
        flags: ImGuiTreeNodeFlags,
        fmt: *const ::core::ffi::c_char,
        ...
    ) -> bool;
    pub fn igTreeNodeEx_Ptr(
        ptr_id: *const ::core::ffi::c_void,
        flags: ImGuiTreeNodeFlags,
        fmt: *const ::core::ffi::c_char,
        ...
    ) -> bool;
    pub fn igTreeNodeExV_Str(
        str_id: *const ::core::ffi::c_char,
        flags: ImGuiTreeNodeFlags,
        fmt: *const ::core::ffi::c_char,
        args: va_list,
    ) -> bool;
    pub fn igTreeNodeExV_Ptr(
        ptr_id: *const ::core::ffi::c_void,
        flags: ImGuiTreeNodeFlags,
        fmt: *const ::core::ffi::c_char,
        args: va_list,
    ) -> bool;
    pub fn igTreePush_Str(str_id: *const ::core::ffi::c_char);
    pub fn igTreePush_Ptr(ptr_id: *const ::core::ffi::c_void);
    pub fn igTreePop();
    pub fn igGetTreeNodeToLabelSpacing() -> f32;
    pub fn igCollapsingHeader_TreeNodeFlags(label: *const ::core::ffi::c_char, flags: ImGuiTreeNodeFlags) -> bool;
    pub fn igCollapsingHeader_BoolPtr(label: *const ::core::ffi::c_char, p_visible: *mut bool, flags: ImGuiTreeNodeFlags)
    -> bool;
    pub fn igSetNextItemOpen(is_open: bool, cond: ImGuiCond);
    pub fn igSetNextItemStorageID(storage_id: ImGuiID);
    pub fn igTreeNodeGetOpen(storage_id: ImGuiID) -> bool;
    pub fn igSelectable_Bool(
        label: *const ::core::ffi::c_char,
        selected: bool,
        flags: ImGuiSelectableFlags,
        size: ImVec2_c,
    ) -> bool;
    pub fn igSelectable_BoolPtr(
        label: *const ::core::ffi::c_char,
        p_selected: *mut bool,
        flags: ImGuiSelectableFlags,
        size: ImVec2_c,
    ) -> bool;
    pub fn igBeginMultiSelect(
        flags: ImGuiMultiSelectFlags,
        selection_size: ::core::ffi::c_int,
        items_count: ::core::ffi::c_int,
    ) -> *mut ImGuiMultiSelectIO;
    pub fn igEndMultiSelect() -> *mut ImGuiMultiSelectIO;
    pub fn igSetNextItemSelectionUserData(selection_user_data: ImGuiSelectionUserData);
    pub fn igIsItemToggledSelection() -> bool;
    pub fn igBeginListBox(label: *const ::core::ffi::c_char, size: ImVec2_c) -> bool;
    pub fn igEndListBox();
    pub fn igListBox_Str_arr(
        label: *const ::core::ffi::c_char,
        current_item: *mut ::core::ffi::c_int,
        items: *const *const ::core::ffi::c_char,
        items_count: ::core::ffi::c_int,
        height_in_items: ::core::ffi::c_int,
    ) -> bool;
    pub fn igListBox_FnStrPtr(
        label: *const ::core::ffi::c_char,
        current_item: *mut ::core::ffi::c_int,
        getter: ::core::option::Option<
            unsafe extern "C" fn(user_data: *mut ::core::ffi::c_void, idx: ::core::ffi::c_int) -> *const ::core::ffi::c_char,
        >,
        user_data: *mut ::core::ffi::c_void,
        items_count: ::core::ffi::c_int,
        height_in_items: ::core::ffi::c_int,
    ) -> bool;
    pub fn igPlotLines_FloatPtr(
        label: *const ::core::ffi::c_char,
        values: *const f32,
        values_count: ::core::ffi::c_int,
        values_offset: ::core::ffi::c_int,
        overlay_text: *const ::core::ffi::c_char,
        scale_min: f32,
        scale_max: f32,
        graph_size: ImVec2_c,
        stride: ::core::ffi::c_int,
    );
    pub fn igPlotLines_FnFloatPtr(
        label: *const ::core::ffi::c_char,
        values_getter: ::core::option::Option<
            unsafe extern "C" fn(data: *mut ::core::ffi::c_void, idx: ::core::ffi::c_int) -> f32,
        >,
        data: *mut ::core::ffi::c_void,
        values_count: ::core::ffi::c_int,
        values_offset: ::core::ffi::c_int,
        overlay_text: *const ::core::ffi::c_char,
        scale_min: f32,
        scale_max: f32,
        graph_size: ImVec2_c,
    );
    pub fn igPlotHistogram_FloatPtr(
        label: *const ::core::ffi::c_char,
        values: *const f32,
        values_count: ::core::ffi::c_int,
        values_offset: ::core::ffi::c_int,
        overlay_text: *const ::core::ffi::c_char,
        scale_min: f32,
        scale_max: f32,
        graph_size: ImVec2_c,
        stride: ::core::ffi::c_int,
    );
    pub fn igPlotHistogram_FnFloatPtr(
        label: *const ::core::ffi::c_char,
        values_getter: ::core::option::Option<
            unsafe extern "C" fn(data: *mut ::core::ffi::c_void, idx: ::core::ffi::c_int) -> f32,
        >,
        data: *mut ::core::ffi::c_void,
        values_count: ::core::ffi::c_int,
        values_offset: ::core::ffi::c_int,
        overlay_text: *const ::core::ffi::c_char,
        scale_min: f32,
        scale_max: f32,
        graph_size: ImVec2_c,
    );
    pub fn igValue_Bool(prefix: *const ::core::ffi::c_char, b: bool);
    pub fn igValue_Int(prefix: *const ::core::ffi::c_char, v: ::core::ffi::c_int);
    pub fn igValue_Uint(prefix: *const ::core::ffi::c_char, v: ::core::ffi::c_uint);
    pub fn igValue_Float(prefix: *const ::core::ffi::c_char, v: f32, float_format: *const ::core::ffi::c_char);
    pub fn igBeginMenuBar() -> bool;
    pub fn igEndMenuBar();
    pub fn igBeginMainMenuBar() -> bool;
    pub fn igEndMainMenuBar();
    pub fn igBeginMenu(label: *const ::core::ffi::c_char, enabled: bool) -> bool;
    pub fn igEndMenu();
    pub fn igMenuItem_Bool(
        label: *const ::core::ffi::c_char,
        shortcut: *const ::core::ffi::c_char,
        selected: bool,
        enabled: bool,
    ) -> bool;
    pub fn igMenuItem_BoolPtr(
        label: *const ::core::ffi::c_char,
        shortcut: *const ::core::ffi::c_char,
        p_selected: *mut bool,
        enabled: bool,
    ) -> bool;
    pub fn igBeginTooltip() -> bool;
    pub fn igEndTooltip();
    pub fn igSetTooltip(fmt: *const ::core::ffi::c_char, ...);
    pub fn igSetTooltipV(fmt: *const ::core::ffi::c_char, args: va_list);
    pub fn igBeginItemTooltip() -> bool;
    pub fn igSetItemTooltip(fmt: *const ::core::ffi::c_char, ...);
    pub fn igSetItemTooltipV(fmt: *const ::core::ffi::c_char, args: va_list);
    pub fn igBeginPopup(str_id: *const ::core::ffi::c_char, flags: ImGuiWindowFlags) -> bool;
    pub fn igBeginPopupModal(name: *const ::core::ffi::c_char, p_open: *mut bool, flags: ImGuiWindowFlags) -> bool;
    pub fn igEndPopup();
    pub fn igOpenPopup_Str(str_id: *const ::core::ffi::c_char, popup_flags: ImGuiPopupFlags);
    pub fn igOpenPopup_ID(id: ImGuiID, popup_flags: ImGuiPopupFlags);
    pub fn igOpenPopupOnItemClick(str_id: *const ::core::ffi::c_char, popup_flags: ImGuiPopupFlags);
    pub fn igCloseCurrentPopup();
    pub fn igBeginPopupContextItem(str_id: *const ::core::ffi::c_char, popup_flags: ImGuiPopupFlags) -> bool;
    pub fn igBeginPopupContextWindow(str_id: *const ::core::ffi::c_char, popup_flags: ImGuiPopupFlags) -> bool;
    pub fn igBeginPopupContextVoid(str_id: *const ::core::ffi::c_char, popup_flags: ImGuiPopupFlags) -> bool;
    pub fn igIsPopupOpen_Str(str_id: *const ::core::ffi::c_char, flags: ImGuiPopupFlags) -> bool;
    pub fn igBeginTable(
        str_id: *const ::core::ffi::c_char,
        columns: ::core::ffi::c_int,
        flags: ImGuiTableFlags,
        outer_size: ImVec2_c,
        inner_width: f32,
    ) -> bool;
    pub fn igEndTable();
    pub fn igTableNextRow(row_flags: ImGuiTableRowFlags, min_row_height: f32);
    pub fn igTableNextColumn() -> bool;
    pub fn igTableSetColumnIndex(column_n: ::core::ffi::c_int) -> bool;
    pub fn igTableSetupColumn(
        label: *const ::core::ffi::c_char,
        flags: ImGuiTableColumnFlags,
        init_width_or_weight: f32,
        user_id: ImGuiID,
    );
    pub fn igTableSetupScrollFreeze(cols: ::core::ffi::c_int, rows: ::core::ffi::c_int);
    pub fn igTableHeader(label: *const ::core::ffi::c_char);
    pub fn igTableHeadersRow();
    pub fn igTableAngledHeadersRow();
    pub fn igTableGetSortSpecs() -> *mut ImGuiTableSortSpecs;
    pub fn igTableGetColumnCount() -> ::core::ffi::c_int;
    pub fn igTableGetColumnIndex() -> ::core::ffi::c_int;
    pub fn igTableGetRowIndex() -> ::core::ffi::c_int;
    pub fn igTableGetColumnName_Int(column_n: ::core::ffi::c_int) -> *const ::core::ffi::c_char;
    pub fn igTableGetColumnFlags(column_n: ::core::ffi::c_int) -> ImGuiTableColumnFlags;
    pub fn igTableSetColumnEnabled(column_n: ::core::ffi::c_int, v: bool);
    pub fn igTableGetHoveredColumn() -> ::core::ffi::c_int;
    pub fn igTableSetBgColor(target: ImGuiTableBgTarget, color: ImU32, column_n: ::core::ffi::c_int);
    pub fn igColumns(count: ::core::ffi::c_int, id: *const ::core::ffi::c_char, borders: bool);
    pub fn igNextColumn();
    pub fn igGetColumnIndex() -> ::core::ffi::c_int;
    pub fn igGetColumnWidth(column_index: ::core::ffi::c_int) -> f32;
    pub fn igSetColumnWidth(column_index: ::core::ffi::c_int, width: f32);
    pub fn igGetColumnOffset(column_index: ::core::ffi::c_int) -> f32;
    pub fn igSetColumnOffset(column_index: ::core::ffi::c_int, offset_x: f32);
    pub fn igGetColumnsCount() -> ::core::ffi::c_int;
    pub fn igBeginTabBar(str_id: *const ::core::ffi::c_char, flags: ImGuiTabBarFlags) -> bool;
    pub fn igEndTabBar();
    pub fn igBeginTabItem(label: *const ::core::ffi::c_char, p_open: *mut bool, flags: ImGuiTabItemFlags) -> bool;
    pub fn igEndTabItem();
    pub fn igTabItemButton(label: *const ::core::ffi::c_char, flags: ImGuiTabItemFlags) -> bool;
    pub fn igSetTabItemClosed(tab_or_docked_window_label: *const ::core::ffi::c_char);
    pub fn igLogToTTY(auto_open_depth: ::core::ffi::c_int);
    pub fn igLogToFile(auto_open_depth: ::core::ffi::c_int, filename: *const ::core::ffi::c_char);
    pub fn igLogToClipboard(auto_open_depth: ::core::ffi::c_int);
    pub fn igLogFinish();
    pub fn igLogButtons();
    pub fn igLogText(fmt: *const ::core::ffi::c_char, ...);
    pub fn igLogTextV(fmt: *const ::core::ffi::c_char, args: va_list);
    pub fn igBeginDragDropSource(flags: ImGuiDragDropFlags) -> bool;
    pub fn igSetDragDropPayload(
        type_: *const ::core::ffi::c_char,
        data: *const ::core::ffi::c_void,
        sz: usize,
        cond: ImGuiCond,
    ) -> bool;
    pub fn igEndDragDropSource();
    pub fn igBeginDragDropTarget() -> bool;
    pub fn igAcceptDragDropPayload(type_: *const ::core::ffi::c_char, flags: ImGuiDragDropFlags) -> *const ImGuiPayload;
    pub fn igEndDragDropTarget();
    pub fn igGetDragDropPayload() -> *const ImGuiPayload;
    pub fn igBeginDisabled(disabled: bool);
    pub fn igEndDisabled();
    pub fn igPushClipRect(clip_rect_min: ImVec2_c, clip_rect_max: ImVec2_c, intersect_with_current_clip_rect: bool);
    pub fn igPopClipRect();
    pub fn igSetItemDefaultFocus();
    pub fn igSetKeyboardFocusHere(offset: ::core::ffi::c_int);
    pub fn igSetNavCursorVisible(visible: bool);
    pub fn igSetNextItemAllowOverlap();
    pub fn igIsItemHovered(flags: ImGuiHoveredFlags) -> bool;
    pub fn igIsItemActive() -> bool;
    pub fn igIsItemFocused() -> bool;
    pub fn igIsItemClicked(mouse_button: ImGuiMouseButton) -> bool;
    pub fn igIsItemVisible() -> bool;
    pub fn igIsItemEdited() -> bool;
    pub fn igIsItemActivated() -> bool;
    pub fn igIsItemDeactivated() -> bool;
    pub fn igIsItemDeactivatedAfterEdit() -> bool;
    pub fn igIsItemToggledOpen() -> bool;
    pub fn igIsAnyItemHovered() -> bool;
    pub fn igIsAnyItemActive() -> bool;
    pub fn igIsAnyItemFocused() -> bool;
    pub fn igGetItemID() -> ImGuiID;
    pub fn igGetItemRectMin() -> ImVec2_c;
    pub fn igGetItemRectMax() -> ImVec2_c;
    pub fn igGetItemRectSize() -> ImVec2_c;
    pub fn igGetItemFlags() -> ImGuiItemFlags;
    pub fn igGetMainViewport() -> *mut ImGuiViewport;
    pub fn igGetBackgroundDrawList_Nil() -> *mut ImDrawList;
    pub fn igGetForegroundDrawList_Nil() -> *mut ImDrawList;
    pub fn igIsRectVisible_Nil(size: ImVec2_c) -> bool;
    pub fn igIsRectVisible_Vec2(rect_min: ImVec2_c, rect_max: ImVec2_c) -> bool;
    pub fn igGetTime() -> f64;
    pub fn igGetFrameCount() -> ::core::ffi::c_int;
    pub fn igGetDrawListSharedData() -> *mut ImDrawListSharedData;
    pub fn igGetStyleColorName(idx: ImGuiCol) -> *const ::core::ffi::c_char;
    pub fn igSetStateStorage(storage: *mut ImGuiStorage);
    pub fn igGetStateStorage() -> *mut ImGuiStorage;
    pub fn igCalcTextSize(
        text: *const ::core::ffi::c_char,
        text_end: *const ::core::ffi::c_char,
        hide_text_after_double_hash: bool,
        wrap_width: f32,
    ) -> ImVec2_c;
    pub fn igColorConvertU32ToFloat4(in_: ImU32) -> ImVec4_c;
    pub fn igColorConvertFloat4ToU32(in_: ImVec4_c) -> ImU32;
    pub fn igColorConvertRGBtoHSV(r: f32, g: f32, b: f32, out_h: *mut f32, out_s: *mut f32, out_v: *mut f32);
    pub fn igColorConvertHSVtoRGB(h: f32, s: f32, v: f32, out_r: *mut f32, out_g: *mut f32, out_b: *mut f32);
    pub fn igIsKeyDown_Nil(key: ImGuiKey) -> bool;
    pub fn igIsKeyPressed_Bool(key: ImGuiKey, repeat: bool) -> bool;
    pub fn igIsKeyReleased_Nil(key: ImGuiKey) -> bool;
    pub fn igIsKeyChordPressed_Nil(key_chord: ImGuiKeyChord) -> bool;
    pub fn igGetKeyPressedAmount(key: ImGuiKey, repeat_delay: f32, rate: f32) -> ::core::ffi::c_int;
    pub fn igGetKeyName(key: ImGuiKey) -> *const ::core::ffi::c_char;
    pub fn igSetNextFrameWantCaptureKeyboard(want_capture_keyboard: bool);
    pub fn igShortcut_Nil(key_chord: ImGuiKeyChord, flags: ImGuiInputFlags) -> bool;
    pub fn igSetNextItemShortcut(key_chord: ImGuiKeyChord, flags: ImGuiInputFlags);
    pub fn igSetItemKeyOwner_Nil(key: ImGuiKey) -> bool;
    pub fn igIsMouseDown_Nil(button: ImGuiMouseButton) -> bool;
    pub fn igIsMouseClicked_Bool(button: ImGuiMouseButton, repeat: bool) -> bool;
    pub fn igIsMouseReleased_Nil(button: ImGuiMouseButton) -> bool;
    pub fn igIsMouseDoubleClicked_Nil(button: ImGuiMouseButton) -> bool;
    pub fn igIsMouseReleasedWithDelay(button: ImGuiMouseButton, delay: f32) -> bool;
    pub fn igGetMouseClickedCount(button: ImGuiMouseButton) -> ::core::ffi::c_int;
    pub fn igIsMouseHoveringRect(r_min: ImVec2_c, r_max: ImVec2_c, clip: bool) -> bool;
    pub fn igIsMousePosValid(mouse_pos: *const ImVec2_c) -> bool;
    pub fn igIsAnyMouseDown() -> bool;
    pub fn igGetMousePos() -> ImVec2_c;
    pub fn igGetMousePosOnOpeningCurrentPopup() -> ImVec2_c;
    pub fn igIsMouseDragging(button: ImGuiMouseButton, lock_threshold: f32) -> bool;
    pub fn igGetMouseDragDelta(button: ImGuiMouseButton, lock_threshold: f32) -> ImVec2_c;
    pub fn igResetMouseDragDelta(button: ImGuiMouseButton);
    pub fn igGetMouseCursor() -> ImGuiMouseCursor;
    pub fn igSetMouseCursor(cursor_type: ImGuiMouseCursor);
    pub fn igSetNextFrameWantCaptureMouse(want_capture_mouse: bool);
    pub fn igGetClipboardText() -> *const ::core::ffi::c_char;
    pub fn igSetClipboardText(text: *const ::core::ffi::c_char);
    pub fn igLoadIniSettingsFromDisk(ini_filename: *const ::core::ffi::c_char);
    pub fn igLoadIniSettingsFromMemory(ini_data: *const ::core::ffi::c_char, ini_size: usize);
    pub fn igSaveIniSettingsToDisk(ini_filename: *const ::core::ffi::c_char);
    pub fn igSaveIniSettingsToMemory(out_ini_size: *mut usize) -> *const ::core::ffi::c_char;
    pub fn igDebugTextEncoding(text: *const ::core::ffi::c_char);
    pub fn igDebugFlashStyleColor(idx: ImGuiCol);
    pub fn igDebugStartItemPicker();
    pub fn igDebugCheckVersionAndDataLayout(
        version_str: *const ::core::ffi::c_char,
        sz_io: usize,
        sz_style: usize,
        sz_vec2: usize,
        sz_vec4: usize,
        sz_drawvert: usize,
        sz_drawidx: usize,
    ) -> bool;
    pub fn igDebugLog(fmt: *const ::core::ffi::c_char, ...);
    pub fn igDebugLogV(fmt: *const ::core::ffi::c_char, args: va_list);
    pub fn igSetAllocatorFunctions(
        alloc_func: ImGuiMemAllocFunc,
        free_func: ImGuiMemFreeFunc,
        user_data: *mut ::core::ffi::c_void,
    );
    pub fn igGetAllocatorFunctions(
        p_alloc_func: *mut ImGuiMemAllocFunc,
        p_free_func: *mut ImGuiMemFreeFunc,
        p_user_data: *mut *mut ::core::ffi::c_void,
    );
    pub fn igMemAlloc(size: usize) -> *mut ::core::ffi::c_void;
    pub fn igMemFree(ptr: *mut ::core::ffi::c_void);
    pub fn ImGuiTableSortSpecs_ImGuiTableSortSpecs() -> *mut ImGuiTableSortSpecs;
    pub fn ImGuiTableSortSpecs_destroy(self_: *mut ImGuiTableSortSpecs);
    pub fn ImGuiTableColumnSortSpecs_ImGuiTableColumnSortSpecs() -> *mut ImGuiTableColumnSortSpecs;
    pub fn ImGuiTableColumnSortSpecs_destroy(self_: *mut ImGuiTableColumnSortSpecs);
    pub fn ImGuiStyle_ImGuiStyle() -> *mut ImGuiStyle;
    pub fn ImGuiStyle_destroy(self_: *mut ImGuiStyle);
    pub fn ImGuiStyle_ScaleAllSizes(self_: *mut ImGuiStyle, scale_factor: f32);
    pub fn ImGuiIO_AddKeyEvent(self_: *mut ImGuiIO, key: ImGuiKey, down: bool);
    pub fn ImGuiIO_AddKeyAnalogEvent(self_: *mut ImGuiIO, key: ImGuiKey, down: bool, v: f32);
    pub fn ImGuiIO_AddMousePosEvent(self_: *mut ImGuiIO, x: f32, y: f32);
    pub fn ImGuiIO_AddMouseButtonEvent(self_: *mut ImGuiIO, button: ::core::ffi::c_int, down: bool);
    pub fn ImGuiIO_AddMouseWheelEvent(self_: *mut ImGuiIO, wheel_x: f32, wheel_y: f32);
    pub fn ImGuiIO_AddMouseSourceEvent(self_: *mut ImGuiIO, source: ImGuiMouseSource);
    pub fn ImGuiIO_AddFocusEvent(self_: *mut ImGuiIO, focused: bool);
    pub fn ImGuiIO_AddInputCharacter(self_: *mut ImGuiIO, c: ::core::ffi::c_uint);
    pub fn ImGuiIO_AddInputCharacterUTF16(self_: *mut ImGuiIO, c: ImWchar16);
    pub fn ImGuiIO_AddInputCharactersUTF8(self_: *mut ImGuiIO, str_: *const ::core::ffi::c_char);
    pub fn ImGuiIO_SetKeyEventNativeData(
        self_: *mut ImGuiIO,
        key: ImGuiKey,
        native_keycode: ::core::ffi::c_int,
        native_scancode: ::core::ffi::c_int,
        native_legacy_index: ::core::ffi::c_int,
    );
    pub fn ImGuiIO_SetAppAcceptingEvents(self_: *mut ImGuiIO, accepting_events: bool);
    pub fn ImGuiIO_ClearEventsQueue(self_: *mut ImGuiIO);
    pub fn ImGuiIO_ClearInputKeys(self_: *mut ImGuiIO);
    pub fn ImGuiIO_ClearInputMouse(self_: *mut ImGuiIO);
    pub fn ImGuiIO_ImGuiIO() -> *mut ImGuiIO;
    pub fn ImGuiIO_destroy(self_: *mut ImGuiIO);
    pub fn ImGuiInputTextCallbackData_ImGuiInputTextCallbackData() -> *mut ImGuiInputTextCallbackData;
    pub fn ImGuiInputTextCallbackData_destroy(self_: *mut ImGuiInputTextCallbackData);
    pub fn ImGuiInputTextCallbackData_DeleteChars(
        self_: *mut ImGuiInputTextCallbackData,
        pos: ::core::ffi::c_int,
        bytes_count: ::core::ffi::c_int,
    );
    pub fn ImGuiInputTextCallbackData_InsertChars(
        self_: *mut ImGuiInputTextCallbackData,
        pos: ::core::ffi::c_int,
        text: *const ::core::ffi::c_char,
        text_end: *const ::core::ffi::c_char,
    );
    pub fn ImGuiInputTextCallbackData_SelectAll(self_: *mut ImGuiInputTextCallbackData);
    pub fn ImGuiInputTextCallbackData_SetSelection(
        self_: *mut ImGuiInputTextCallbackData,
        s: ::core::ffi::c_int,
        e: ::core::ffi::c_int,
    );
    pub fn ImGuiInputTextCallbackData_ClearSelection(self_: *mut ImGuiInputTextCallbackData);
    pub fn ImGuiInputTextCallbackData_HasSelection(self_: *mut ImGuiInputTextCallbackData) -> bool;
    pub fn ImGuiPayload_ImGuiPayload() -> *mut ImGuiPayload;
    pub fn ImGuiPayload_destroy(self_: *mut ImGuiPayload);
    pub fn ImGuiPayload_Clear(self_: *mut ImGuiPayload);
    pub fn ImGuiPayload_IsDataType(self_: *mut ImGuiPayload, type_: *const ::core::ffi::c_char) -> bool;
    pub fn ImGuiPayload_IsPreview(self_: *mut ImGuiPayload) -> bool;
    pub fn ImGuiPayload_IsDelivery(self_: *mut ImGuiPayload) -> bool;
    pub fn ImGuiOnceUponAFrame_ImGuiOnceUponAFrame() -> *mut ImGuiOnceUponAFrame;
    pub fn ImGuiOnceUponAFrame_destroy(self_: *mut ImGuiOnceUponAFrame);
    pub fn ImGuiTextFilter_ImGuiTextFilter(default_filter: *const ::core::ffi::c_char) -> *mut ImGuiTextFilter;
    pub fn ImGuiTextFilter_destroy(self_: *mut ImGuiTextFilter);
    pub fn ImGuiTextFilter_Draw(self_: *mut ImGuiTextFilter, label: *const ::core::ffi::c_char, width: f32) -> bool;
    pub fn ImGuiTextFilter_PassFilter(
        self_: *mut ImGuiTextFilter,
        text: *const ::core::ffi::c_char,
        text_end: *const ::core::ffi::c_char,
    ) -> bool;
    pub fn ImGuiTextFilter_Build(self_: *mut ImGuiTextFilter);
    pub fn ImGuiTextFilter_Clear(self_: *mut ImGuiTextFilter);
    pub fn ImGuiTextFilter_IsActive(self_: *mut ImGuiTextFilter) -> bool;
    pub fn ImGuiTextRange_ImGuiTextRange_Nil() -> *mut ImGuiTextRange;
    pub fn ImGuiTextRange_destroy(self_: *mut ImGuiTextRange);
    pub fn ImGuiTextRange_ImGuiTextRange_Str(
        _b: *const ::core::ffi::c_char,
        _e: *const ::core::ffi::c_char,
    ) -> *mut ImGuiTextRange;
    pub fn ImGuiTextRange_empty(self_: *mut ImGuiTextRange) -> bool;
    pub fn ImGuiTextRange_split(self_: *mut ImGuiTextRange, separator: ::core::ffi::c_char, out: *mut ImVector_ImGuiTextRange);
    pub fn ImGuiTextBuffer_ImGuiTextBuffer() -> *mut ImGuiTextBuffer;
    pub fn ImGuiTextBuffer_destroy(self_: *mut ImGuiTextBuffer);
    pub fn ImGuiTextBuffer_begin(self_: *mut ImGuiTextBuffer) -> *const ::core::ffi::c_char;
    pub fn ImGuiTextBuffer_end(self_: *mut ImGuiTextBuffer) -> *const ::core::ffi::c_char;
    pub fn ImGuiTextBuffer_size(self_: *mut ImGuiTextBuffer) -> ::core::ffi::c_int;
    pub fn ImGuiTextBuffer_empty(self_: *mut ImGuiTextBuffer) -> bool;
    pub fn ImGuiTextBuffer_clear(self_: *mut ImGuiTextBuffer);
    pub fn ImGuiTextBuffer_resize(self_: *mut ImGuiTextBuffer, size: ::core::ffi::c_int);
    pub fn ImGuiTextBuffer_reserve(self_: *mut ImGuiTextBuffer, capacity: ::core::ffi::c_int);
    pub fn ImGuiTextBuffer_c_str(self_: *mut ImGuiTextBuffer) -> *const ::core::ffi::c_char;
    pub fn ImGuiTextBuffer_append(
        self_: *mut ImGuiTextBuffer,
        str_: *const ::core::ffi::c_char,
        str_end: *const ::core::ffi::c_char,
    );
    pub fn ImGuiTextBuffer_appendfv(self_: *mut ImGuiTextBuffer, fmt: *const ::core::ffi::c_char, args: va_list);
    pub fn ImGuiStoragePair_ImGuiStoragePair_Int(_key: ImGuiID, _val: ::core::ffi::c_int) -> *mut ImGuiStoragePair;
    pub fn ImGuiStoragePair_destroy(self_: *mut ImGuiStoragePair);
    pub fn ImGuiStoragePair_ImGuiStoragePair_Float(_key: ImGuiID, _val: f32) -> *mut ImGuiStoragePair;
    pub fn ImGuiStoragePair_ImGuiStoragePair_Ptr(_key: ImGuiID, _val: *mut ::core::ffi::c_void) -> *mut ImGuiStoragePair;
    pub fn ImGuiStorage_Clear(self_: *mut ImGuiStorage);
    pub fn ImGuiStorage_GetInt(self_: *mut ImGuiStorage, key: ImGuiID, default_val: ::core::ffi::c_int) -> ::core::ffi::c_int;
    pub fn ImGuiStorage_SetInt(self_: *mut ImGuiStorage, key: ImGuiID, val: ::core::ffi::c_int);
    pub fn ImGuiStorage_GetBool(self_: *mut ImGuiStorage, key: ImGuiID, default_val: bool) -> bool;
    pub fn ImGuiStorage_SetBool(self_: *mut ImGuiStorage, key: ImGuiID, val: bool);
    pub fn ImGuiStorage_GetFloat(self_: *mut ImGuiStorage, key: ImGuiID, default_val: f32) -> f32;
    pub fn ImGuiStorage_SetFloat(self_: *mut ImGuiStorage, key: ImGuiID, val: f32);
    pub fn ImGuiStorage_GetVoidPtr(self_: *mut ImGuiStorage, key: ImGuiID) -> *mut ::core::ffi::c_void;
    pub fn ImGuiStorage_SetVoidPtr(self_: *mut ImGuiStorage, key: ImGuiID, val: *mut ::core::ffi::c_void);
    pub fn ImGuiStorage_GetIntRef(
        self_: *mut ImGuiStorage,
        key: ImGuiID,
        default_val: ::core::ffi::c_int,
    ) -> *mut ::core::ffi::c_int;
    pub fn ImGuiStorage_GetBoolRef(self_: *mut ImGuiStorage, key: ImGuiID, default_val: bool) -> *mut bool;
    pub fn ImGuiStorage_GetFloatRef(self_: *mut ImGuiStorage, key: ImGuiID, default_val: f32) -> *mut f32;
    pub fn ImGuiStorage_GetVoidPtrRef(
        self_: *mut ImGuiStorage,
        key: ImGuiID,
        default_val: *mut ::core::ffi::c_void,
    ) -> *mut *mut ::core::ffi::c_void;
    pub fn ImGuiStorage_BuildSortByKey(self_: *mut ImGuiStorage);
    pub fn ImGuiStorage_SetAllInt(self_: *mut ImGuiStorage, val: ::core::ffi::c_int);
    pub fn ImGuiListClipper_ImGuiListClipper() -> *mut ImGuiListClipper;
    pub fn ImGuiListClipper_destroy(self_: *mut ImGuiListClipper);
    pub fn ImGuiListClipper_Begin(self_: *mut ImGuiListClipper, items_count: ::core::ffi::c_int, items_height: f32);
    pub fn ImGuiListClipper_End(self_: *mut ImGuiListClipper);
    pub fn ImGuiListClipper_Step(self_: *mut ImGuiListClipper) -> bool;
    pub fn ImGuiListClipper_IncludeItemByIndex(self_: *mut ImGuiListClipper, item_index: ::core::ffi::c_int);
    pub fn ImGuiListClipper_IncludeItemsByIndex(
        self_: *mut ImGuiListClipper,
        item_begin: ::core::ffi::c_int,
        item_end: ::core::ffi::c_int,
    );
    pub fn ImGuiListClipper_SeekCursorForItem(self_: *mut ImGuiListClipper, item_index: ::core::ffi::c_int);
    pub fn ImColor_ImColor_Nil() -> *mut ImColor;
    pub fn ImColor_destroy(self_: *mut ImColor);
    pub fn ImColor_ImColor_Float(r: f32, g: f32, b: f32, a: f32) -> *mut ImColor;
    pub fn ImColor_ImColor_Vec4(col: ImVec4_c) -> *mut ImColor;
    pub fn ImColor_ImColor_Int(
        r: ::core::ffi::c_int,
        g: ::core::ffi::c_int,
        b: ::core::ffi::c_int,
        a: ::core::ffi::c_int,
    ) -> *mut ImColor;
    pub fn ImColor_ImColor_U32(rgba: ImU32) -> *mut ImColor;
    pub fn ImColor_SetHSV(self_: *mut ImColor, h: f32, s: f32, v: f32, a: f32);
    pub fn ImColor_HSV(h: f32, s: f32, v: f32, a: f32) -> ImColor_c;
    pub fn ImGuiSelectionBasicStorage_ImGuiSelectionBasicStorage() -> *mut ImGuiSelectionBasicStorage;
    pub fn ImGuiSelectionBasicStorage_destroy(self_: *mut ImGuiSelectionBasicStorage);
    pub fn ImGuiSelectionBasicStorage_ApplyRequests(self_: *mut ImGuiSelectionBasicStorage, ms_io: *mut ImGuiMultiSelectIO);
    pub fn ImGuiSelectionBasicStorage_Contains(self_: *mut ImGuiSelectionBasicStorage, id: ImGuiID) -> bool;
    pub fn ImGuiSelectionBasicStorage_Clear(self_: *mut ImGuiSelectionBasicStorage);
    pub fn ImGuiSelectionBasicStorage_Swap(self_: *mut ImGuiSelectionBasicStorage, r: *mut ImGuiSelectionBasicStorage);
    pub fn ImGuiSelectionBasicStorage_SetItemSelected(self_: *mut ImGuiSelectionBasicStorage, id: ImGuiID, selected: bool);
    pub fn ImGuiSelectionBasicStorage_GetNextSelectedItem(
        self_: *mut ImGuiSelectionBasicStorage,
        opaque_it: *mut *mut ::core::ffi::c_void,
        out_id: *mut ImGuiID,
    ) -> bool;
    pub fn ImGuiSelectionBasicStorage_GetStorageIdFromIndex(
        self_: *mut ImGuiSelectionBasicStorage,
        idx: ::core::ffi::c_int,
    ) -> ImGuiID;
    pub fn ImGuiSelectionExternalStorage_ImGuiSelectionExternalStorage() -> *mut ImGuiSelectionExternalStorage;
    pub fn ImGuiSelectionExternalStorage_destroy(self_: *mut ImGuiSelectionExternalStorage);
    pub fn ImGuiSelectionExternalStorage_ApplyRequests(self_: *mut ImGuiSelectionExternalStorage, ms_io: *mut ImGuiMultiSelectIO);
    pub fn ImDrawCmd_ImDrawCmd() -> *mut ImDrawCmd;
    pub fn ImDrawCmd_destroy(self_: *mut ImDrawCmd);
    pub fn ImDrawCmd_GetTexID(self_: *mut ImDrawCmd) -> ImTextureID;
    pub fn ImDrawListSplitter_ImDrawListSplitter() -> *mut ImDrawListSplitter;
    pub fn ImDrawListSplitter_destroy(self_: *mut ImDrawListSplitter);
    pub fn ImDrawListSplitter_Clear(self_: *mut ImDrawListSplitter);
    pub fn ImDrawListSplitter_ClearFreeMemory(self_: *mut ImDrawListSplitter);
    pub fn ImDrawListSplitter_Split(self_: *mut ImDrawListSplitter, draw_list: *mut ImDrawList, count: ::core::ffi::c_int);
    pub fn ImDrawListSplitter_Merge(self_: *mut ImDrawListSplitter, draw_list: *mut ImDrawList);
    pub fn ImDrawListSplitter_SetCurrentChannel(
        self_: *mut ImDrawListSplitter,
        draw_list: *mut ImDrawList,
        channel_idx: ::core::ffi::c_int,
    );
    pub fn ImDrawList_ImDrawList(shared_data: *mut ImDrawListSharedData) -> *mut ImDrawList;
    pub fn ImDrawList_destroy(self_: *mut ImDrawList);
    pub fn ImDrawList_PushClipRect(
        self_: *mut ImDrawList,
        clip_rect_min: ImVec2_c,
        clip_rect_max: ImVec2_c,
        intersect_with_current_clip_rect: bool,
    );
    pub fn ImDrawList_PushClipRectFullScreen(self_: *mut ImDrawList);
    pub fn ImDrawList_PopClipRect(self_: *mut ImDrawList);
    pub fn ImDrawList_PushTexture(self_: *mut ImDrawList, tex_ref: ImTextureRef_c);
    pub fn ImDrawList_PopTexture(self_: *mut ImDrawList);
    pub fn ImDrawList_GetClipRectMin(self_: *mut ImDrawList) -> ImVec2_c;
    pub fn ImDrawList_GetClipRectMax(self_: *mut ImDrawList) -> ImVec2_c;
    pub fn ImDrawList_AddLine(self_: *mut ImDrawList, p1: ImVec2_c, p2: ImVec2_c, col: ImU32, thickness: f32);
    pub fn ImDrawList_AddLineH(self_: *mut ImDrawList, min_x: f32, max_x: f32, y: f32, col: ImU32, thickness: f32);
    pub fn ImDrawList_AddLineV(self_: *mut ImDrawList, x: f32, min_y: f32, max_y: f32, col: ImU32, thickness: f32);
    pub fn ImDrawList_AddRect(
        self_: *mut ImDrawList,
        p_min: ImVec2_c,
        p_max: ImVec2_c,
        col: ImU32,
        rounding: f32,
        thickness: f32,
        flags: ImDrawFlags,
    );
    pub fn ImDrawList_AddRectFilled(
        self_: *mut ImDrawList,
        p_min: ImVec2_c,
        p_max: ImVec2_c,
        col: ImU32,
        rounding: f32,
        flags: ImDrawFlags,
    );
    pub fn ImDrawList_AddRectFilledMultiColor(
        self_: *mut ImDrawList,
        p_min: ImVec2_c,
        p_max: ImVec2_c,
        col_upr_left: ImU32,
        col_upr_right: ImU32,
        col_bot_right: ImU32,
        col_bot_left: ImU32,
    );
    pub fn ImDrawList_AddQuad(
        self_: *mut ImDrawList,
        p1: ImVec2_c,
        p2: ImVec2_c,
        p3: ImVec2_c,
        p4: ImVec2_c,
        col: ImU32,
        thickness: f32,
    );
    pub fn ImDrawList_AddQuadFilled(self_: *mut ImDrawList, p1: ImVec2_c, p2: ImVec2_c, p3: ImVec2_c, p4: ImVec2_c, col: ImU32);
    pub fn ImDrawList_AddTriangle(self_: *mut ImDrawList, p1: ImVec2_c, p2: ImVec2_c, p3: ImVec2_c, col: ImU32, thickness: f32);
    pub fn ImDrawList_AddTriangleFilled(self_: *mut ImDrawList, p1: ImVec2_c, p2: ImVec2_c, p3: ImVec2_c, col: ImU32);
    pub fn ImDrawList_AddCircle(
        self_: *mut ImDrawList,
        center: ImVec2_c,
        radius: f32,
        col: ImU32,
        num_segments: ::core::ffi::c_int,
        thickness: f32,
    );
    pub fn ImDrawList_AddCircleFilled(
        self_: *mut ImDrawList,
        center: ImVec2_c,
        radius: f32,
        col: ImU32,
        num_segments: ::core::ffi::c_int,
    );
    pub fn ImDrawList_AddNgon(
        self_: *mut ImDrawList,
        center: ImVec2_c,
        radius: f32,
        col: ImU32,
        num_segments: ::core::ffi::c_int,
        thickness: f32,
    );
    pub fn ImDrawList_AddNgonFilled(
        self_: *mut ImDrawList,
        center: ImVec2_c,
        radius: f32,
        col: ImU32,
        num_segments: ::core::ffi::c_int,
    );
    pub fn ImDrawList_AddEllipse(
        self_: *mut ImDrawList,
        center: ImVec2_c,
        radius: ImVec2_c,
        col: ImU32,
        rot: f32,
        num_segments: ::core::ffi::c_int,
        thickness: f32,
    );
    pub fn ImDrawList_AddEllipseFilled(
        self_: *mut ImDrawList,
        center: ImVec2_c,
        radius: ImVec2_c,
        col: ImU32,
        rot: f32,
        num_segments: ::core::ffi::c_int,
    );
    pub fn ImDrawList_AddText_Vec2(
        self_: *mut ImDrawList,
        pos: ImVec2_c,
        col: ImU32,
        text_begin: *const ::core::ffi::c_char,
        text_end: *const ::core::ffi::c_char,
    );
    pub fn ImDrawList_AddText_FontPtr(
        self_: *mut ImDrawList,
        font: *mut ImFont,
        font_size: f32,
        pos: ImVec2_c,
        col: ImU32,
        text_begin: *const ::core::ffi::c_char,
        text_end: *const ::core::ffi::c_char,
        wrap_width: f32,
        cpu_fine_clip_rect: *const ImVec4,
    );
    pub fn ImDrawList_AddBezierCubic(
        self_: *mut ImDrawList,
        p1: ImVec2_c,
        p2: ImVec2_c,
        p3: ImVec2_c,
        p4: ImVec2_c,
        col: ImU32,
        thickness: f32,
        num_segments: ::core::ffi::c_int,
    );
    pub fn ImDrawList_AddBezierQuadratic(
        self_: *mut ImDrawList,
        p1: ImVec2_c,
        p2: ImVec2_c,
        p3: ImVec2_c,
        col: ImU32,
        thickness: f32,
        num_segments: ::core::ffi::c_int,
    );
    pub fn ImDrawList_AddPolyline(
        self_: *mut ImDrawList,
        points: *const ImVec2_c,
        num_points: ::core::ffi::c_int,
        col: ImU32,
        thickness: f32,
        flags: ImDrawFlags,
    );
    pub fn ImDrawList_AddConvexPolyFilled(
        self_: *mut ImDrawList,
        points: *const ImVec2_c,
        num_points: ::core::ffi::c_int,
        col: ImU32,
    );
    pub fn ImDrawList_AddConcavePolyFilled(
        self_: *mut ImDrawList,
        points: *const ImVec2_c,
        num_points: ::core::ffi::c_int,
        col: ImU32,
    );
    pub fn ImDrawList_AddImage(
        self_: *mut ImDrawList,
        tex_ref: ImTextureRef_c,
        p_min: ImVec2_c,
        p_max: ImVec2_c,
        uv_min: ImVec2_c,
        uv_max: ImVec2_c,
        col: ImU32,
    );
    pub fn ImDrawList_AddImageQuad(
        self_: *mut ImDrawList,
        tex_ref: ImTextureRef_c,
        p1: ImVec2_c,
        p2: ImVec2_c,
        p3: ImVec2_c,
        p4: ImVec2_c,
        uv1: ImVec2_c,
        uv2: ImVec2_c,
        uv3: ImVec2_c,
        uv4: ImVec2_c,
        col: ImU32,
    );
    pub fn ImDrawList_AddImageRounded(
        self_: *mut ImDrawList,
        tex_ref: ImTextureRef_c,
        p_min: ImVec2_c,
        p_max: ImVec2_c,
        uv_min: ImVec2_c,
        uv_max: ImVec2_c,
        col: ImU32,
        rounding: f32,
        flags: ImDrawFlags,
    );
    pub fn ImDrawList_PathClear(self_: *mut ImDrawList);
    pub fn ImDrawList_PathLineTo(self_: *mut ImDrawList, pos: ImVec2_c);
    pub fn ImDrawList_PathLineToMergeDuplicate(self_: *mut ImDrawList, pos: ImVec2_c);
    pub fn ImDrawList_PathFillConvex(self_: *mut ImDrawList, col: ImU32);
    pub fn ImDrawList_PathFillConcave(self_: *mut ImDrawList, col: ImU32);
    pub fn ImDrawList_PathStroke(self_: *mut ImDrawList, col: ImU32, thickness: f32, flags: ImDrawFlags);
    pub fn ImDrawList_PathArcTo(
        self_: *mut ImDrawList,
        center: ImVec2_c,
        radius: f32,
        a_min: f32,
        a_max: f32,
        num_segments: ::core::ffi::c_int,
    );
    pub fn ImDrawList_PathArcToFast(
        self_: *mut ImDrawList,
        center: ImVec2_c,
        radius: f32,
        a_min_of_12: ::core::ffi::c_int,
        a_max_of_12: ::core::ffi::c_int,
    );
    pub fn ImDrawList_PathEllipticalArcTo(
        self_: *mut ImDrawList,
        center: ImVec2_c,
        radius: ImVec2_c,
        rot: f32,
        a_min: f32,
        a_max: f32,
        num_segments: ::core::ffi::c_int,
    );
    pub fn ImDrawList_PathBezierCubicCurveTo(
        self_: *mut ImDrawList,
        p2: ImVec2_c,
        p3: ImVec2_c,
        p4: ImVec2_c,
        num_segments: ::core::ffi::c_int,
    );
    pub fn ImDrawList_PathBezierQuadraticCurveTo(
        self_: *mut ImDrawList,
        p2: ImVec2_c,
        p3: ImVec2_c,
        num_segments: ::core::ffi::c_int,
    );
    pub fn ImDrawList_PathRect(self_: *mut ImDrawList, rect_min: ImVec2_c, rect_max: ImVec2_c, rounding: f32, flags: ImDrawFlags);
    pub fn ImDrawList_AddCallback(
        self_: *mut ImDrawList,
        callback: ImDrawCallback,
        userdata: *mut ::core::ffi::c_void,
        userdata_size: usize,
    );
    pub fn ImDrawList_AddDrawCmd(self_: *mut ImDrawList);
    pub fn ImDrawList_CloneOutput(self_: *mut ImDrawList) -> *mut ImDrawList;
    pub fn ImDrawList_ChannelsSplit(self_: *mut ImDrawList, count: ::core::ffi::c_int);
    pub fn ImDrawList_ChannelsMerge(self_: *mut ImDrawList);
    pub fn ImDrawList_ChannelsSetCurrent(self_: *mut ImDrawList, n: ::core::ffi::c_int);
    pub fn ImDrawList_PrimReserve(self_: *mut ImDrawList, idx_count: ::core::ffi::c_int, vtx_count: ::core::ffi::c_int);
    pub fn ImDrawList_PrimUnreserve(self_: *mut ImDrawList, idx_count: ::core::ffi::c_int, vtx_count: ::core::ffi::c_int);
    pub fn ImDrawList_PrimRect(self_: *mut ImDrawList, a: ImVec2_c, b: ImVec2_c, col: ImU32);
    pub fn ImDrawList_PrimRectUV(self_: *mut ImDrawList, a: ImVec2_c, b: ImVec2_c, uv_a: ImVec2_c, uv_b: ImVec2_c, col: ImU32);
    pub fn ImDrawList_PrimQuadUV(
        self_: *mut ImDrawList,
        a: ImVec2_c,
        b: ImVec2_c,
        c: ImVec2_c,
        d: ImVec2_c,
        uv_a: ImVec2_c,
        uv_b: ImVec2_c,
        uv_c: ImVec2_c,
        uv_d: ImVec2_c,
        col: ImU32,
    );
    pub fn ImDrawList_PrimWriteVtx(self_: *mut ImDrawList, pos: ImVec2_c, uv: ImVec2_c, col: ImU32);
    pub fn ImDrawList_PrimWriteIdx(self_: *mut ImDrawList, idx: ImDrawIdx);
    pub fn ImDrawList_PrimVtx(self_: *mut ImDrawList, pos: ImVec2_c, uv: ImVec2_c, col: ImU32);
    pub fn ImDrawList__SetDrawListSharedData(self_: *mut ImDrawList, data: *mut ImDrawListSharedData);
    pub fn ImDrawList__ResetForNewFrame(self_: *mut ImDrawList);
    pub fn ImDrawList__ClearFreeMemory(self_: *mut ImDrawList);
    pub fn ImDrawList__PopUnusedDrawCmd(self_: *mut ImDrawList);
    pub fn ImDrawList__TryMergeDrawCmds(self_: *mut ImDrawList);
    pub fn ImDrawList__OnChangedClipRect(self_: *mut ImDrawList);
    pub fn ImDrawList__OnChangedTexture(self_: *mut ImDrawList);
    pub fn ImDrawList__OnChangedVtxOffset(self_: *mut ImDrawList);
    pub fn ImDrawList__SetTexture(self_: *mut ImDrawList, tex_ref: ImTextureRef_c);
    pub fn ImDrawList__CalcCircleAutoSegmentCount(self_: *mut ImDrawList, radius: f32) -> ::core::ffi::c_int;
    pub fn ImDrawList__PathArcToFastEx(
        self_: *mut ImDrawList,
        center: ImVec2_c,
        radius: f32,
        a_min_sample: ::core::ffi::c_int,
        a_max_sample: ::core::ffi::c_int,
        a_step: ::core::ffi::c_int,
    );
    pub fn ImDrawList__PathArcToN(
        self_: *mut ImDrawList,
        center: ImVec2_c,
        radius: f32,
        a_min: f32,
        a_max: f32,
        num_segments: ::core::ffi::c_int,
    );
    pub fn ImDrawData_ImDrawData() -> *mut ImDrawData;
    pub fn ImDrawData_destroy(self_: *mut ImDrawData);
    pub fn ImDrawData_Clear(self_: *mut ImDrawData);
    pub fn ImDrawData_AddDrawList(self_: *mut ImDrawData, draw_list: *mut ImDrawList);
    pub fn ImDrawData_DeIndexAllBuffers(self_: *mut ImDrawData);
    pub fn ImDrawData_ScaleClipRects(self_: *mut ImDrawData, fb_scale: ImVec2_c);
    pub fn ImTextureData_ImTextureData() -> *mut ImTextureData;
    pub fn ImTextureData_destroy(self_: *mut ImTextureData);
    pub fn ImTextureData_Create(self_: *mut ImTextureData, format: ImTextureFormat, w: ::core::ffi::c_int, h: ::core::ffi::c_int);
    pub fn ImTextureData_DestroyPixels(self_: *mut ImTextureData);
    pub fn ImTextureData_GetPixels(self_: *mut ImTextureData) -> *mut ::core::ffi::c_void;
    pub fn ImTextureData_GetPixelsAt(
        self_: *mut ImTextureData,
        x: ::core::ffi::c_int,
        y: ::core::ffi::c_int,
    ) -> *mut ::core::ffi::c_void;
    pub fn ImTextureData_GetSizeInBytes(self_: *mut ImTextureData) -> ::core::ffi::c_int;
    pub fn ImTextureData_GetPitch(self_: *mut ImTextureData) -> ::core::ffi::c_int;
    pub fn ImTextureData_GetTexRef(self_: *mut ImTextureData) -> ImTextureRef_c;
    pub fn ImTextureData_GetTexID(self_: *mut ImTextureData) -> ImTextureID;
    pub fn ImTextureData_SetTexID(self_: *mut ImTextureData, tex_id: ImTextureID);
    pub fn ImTextureData_SetStatus(self_: *mut ImTextureData, status: ImTextureStatus);
    pub fn ImFontConfig_ImFontConfig() -> *mut ImFontConfig;
    pub fn ImFontConfig_destroy(self_: *mut ImFontConfig);
    pub fn ImFontGlyph_ImFontGlyph() -> *mut ImFontGlyph;
    pub fn ImFontGlyph_destroy(self_: *mut ImFontGlyph);
    pub fn ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder() -> *mut ImFontGlyphRangesBuilder;
    pub fn ImFontGlyphRangesBuilder_destroy(self_: *mut ImFontGlyphRangesBuilder);
    pub fn ImFontGlyphRangesBuilder_Clear(self_: *mut ImFontGlyphRangesBuilder);
    pub fn ImFontGlyphRangesBuilder_GetBit(self_: *mut ImFontGlyphRangesBuilder, n: usize) -> bool;
    pub fn ImFontGlyphRangesBuilder_SetBit(self_: *mut ImFontGlyphRangesBuilder, n: usize);
    pub fn ImFontGlyphRangesBuilder_AddChar(self_: *mut ImFontGlyphRangesBuilder, c: ImWchar);
    pub fn ImFontGlyphRangesBuilder_AddText(
        self_: *mut ImFontGlyphRangesBuilder,
        text: *const ::core::ffi::c_char,
        text_end: *const ::core::ffi::c_char,
    );
    pub fn ImFontGlyphRangesBuilder_AddRanges(self_: *mut ImFontGlyphRangesBuilder, ranges: *const ImWchar);
    pub fn ImFontGlyphRangesBuilder_BuildRanges(self_: *mut ImFontGlyphRangesBuilder, out_ranges: *mut ImVector_ImWchar);
    pub fn ImFontAtlasRect_ImFontAtlasRect() -> *mut ImFontAtlasRect;
    pub fn ImFontAtlasRect_destroy(self_: *mut ImFontAtlasRect);
    pub fn ImFontAtlas_ImFontAtlas() -> *mut ImFontAtlas;
    pub fn ImFontAtlas_destroy(self_: *mut ImFontAtlas);
    pub fn ImFontAtlas_AddFont(self_: *mut ImFontAtlas, font_cfg: *const ImFontConfig) -> *mut ImFont;
    pub fn ImFontAtlas_AddFontDefault(self_: *mut ImFontAtlas, font_cfg: *const ImFontConfig) -> *mut ImFont;
    pub fn ImFontAtlas_AddFontDefaultVector(self_: *mut ImFontAtlas, font_cfg: *const ImFontConfig) -> *mut ImFont;
    pub fn ImFontAtlas_AddFontDefaultBitmap(self_: *mut ImFontAtlas, font_cfg: *const ImFontConfig) -> *mut ImFont;
    pub fn ImFontAtlas_AddFontFromFileTTF(
        self_: *mut ImFontAtlas,
        filename: *const ::core::ffi::c_char,
        size_pixels: f32,
        font_cfg: *const ImFontConfig,
        glyph_ranges: *const ImWchar,
    ) -> *mut ImFont;
    pub fn ImFontAtlas_AddFontFromMemoryTTF(
        self_: *mut ImFontAtlas,
        font_data: *mut ::core::ffi::c_void,
        font_data_size: ::core::ffi::c_int,
        size_pixels: f32,
        font_cfg: *const ImFontConfig,
        glyph_ranges: *const ImWchar,
    ) -> *mut ImFont;
    pub fn ImFontAtlas_AddFontFromMemoryCompressedTTF(
        self_: *mut ImFontAtlas,
        compressed_font_data: *const ::core::ffi::c_void,
        compressed_font_data_size: ::core::ffi::c_int,
        size_pixels: f32,
        font_cfg: *const ImFontConfig,
        glyph_ranges: *const ImWchar,
    ) -> *mut ImFont;
    pub fn ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(
        self_: *mut ImFontAtlas,
        compressed_font_data_base85: *const ::core::ffi::c_char,
        size_pixels: f32,
        font_cfg: *const ImFontConfig,
        glyph_ranges: *const ImWchar,
    ) -> *mut ImFont;
    pub fn ImFontAtlas_RemoveFont(self_: *mut ImFontAtlas, font: *mut ImFont);
    pub fn ImFontAtlas_Clear(self_: *mut ImFontAtlas);
    pub fn ImFontAtlas_ClearFonts(self_: *mut ImFontAtlas);
    pub fn ImFontAtlas_CompactCache(self_: *mut ImFontAtlas);
    pub fn ImFontAtlas_SetFontLoader(self_: *mut ImFontAtlas, font_loader: *const ImFontLoader);
    pub fn ImFontAtlas_ClearInputData(self_: *mut ImFontAtlas);
    pub fn ImFontAtlas_ClearTexData(self_: *mut ImFontAtlas);
    pub fn ImFontAtlas_GetGlyphRangesDefault(self_: *mut ImFontAtlas) -> *const ImWchar;
    pub fn ImFontAtlas_AddCustomRect(
        self_: *mut ImFontAtlas,
        width: ::core::ffi::c_int,
        height: ::core::ffi::c_int,
        out_r: *mut ImFontAtlasRect,
    ) -> ImFontAtlasRectId;
    pub fn ImFontAtlas_RemoveCustomRect(self_: *mut ImFontAtlas, id: ImFontAtlasRectId);
    pub fn ImFontAtlas_GetCustomRect(self_: *mut ImFontAtlas, id: ImFontAtlasRectId, out_r: *mut ImFontAtlasRect) -> bool;
    pub fn ImFontBaked_ImFontBaked() -> *mut ImFontBaked;
    pub fn ImFontBaked_destroy(self_: *mut ImFontBaked);
    pub fn ImFontBaked_ClearOutputData(self_: *mut ImFontBaked);
    pub fn ImFontBaked_FindGlyph(self_: *mut ImFontBaked, c: ImWchar) -> *mut ImFontGlyph;
    pub fn ImFontBaked_FindGlyphNoFallback(self_: *mut ImFontBaked, c: ImWchar) -> *mut ImFontGlyph;
    pub fn ImFontBaked_GetCharAdvance(self_: *mut ImFontBaked, c: ImWchar) -> f32;
    pub fn ImFontBaked_IsGlyphLoaded(self_: *mut ImFontBaked, c: ImWchar) -> bool;
    pub fn ImFont_ImFont() -> *mut ImFont;
    pub fn ImFont_destroy(self_: *mut ImFont);
    pub fn ImFont_IsGlyphInFont(self_: *mut ImFont, c: ImWchar) -> bool;
    pub fn ImFont_IsLoaded(self_: *mut ImFont) -> bool;
    pub fn ImFont_GetDebugName(self_: *mut ImFont) -> *const ::core::ffi::c_char;
    pub fn ImFont_GetFontBaked(self_: *mut ImFont, font_size: f32, density: f32) -> *mut ImFontBaked;
    pub fn ImFont_CalcTextSizeA(
        self_: *mut ImFont,
        size: f32,
        max_width: f32,
        wrap_width: f32,
        text_begin: *const ::core::ffi::c_char,
        text_end: *const ::core::ffi::c_char,
        out_remaining: *mut *const ::core::ffi::c_char,
    ) -> ImVec2_c;
    pub fn ImFont_CalcWordWrapPosition(
        self_: *mut ImFont,
        size: f32,
        text: *const ::core::ffi::c_char,
        text_end: *const ::core::ffi::c_char,
        wrap_width: f32,
    ) -> *const ::core::ffi::c_char;
    pub fn ImFont_RenderChar(
        self_: *mut ImFont,
        draw_list: *mut ImDrawList,
        size: f32,
        pos: ImVec2_c,
        col: ImU32,
        c: ImWchar,
        cpu_fine_clip: *const ImVec4,
    );
    pub fn ImFont_RenderText(
        self_: *mut ImFont,
        draw_list: *mut ImDrawList,
        size: f32,
        pos: ImVec2_c,
        col: ImU32,
        clip_rect: ImVec4_c,
        text_begin: *const ::core::ffi::c_char,
        text_end: *const ::core::ffi::c_char,
        wrap_width: f32,
        flags: ImDrawTextFlags,
    );
    pub fn ImFont_ClearOutputData(self_: *mut ImFont);
    pub fn ImFont_AddRemapChar(self_: *mut ImFont, from_codepoint: ImWchar, to_codepoint: ImWchar);
    pub fn ImFont_IsGlyphRangeUnused(self_: *mut ImFont, c_begin: ::core::ffi::c_uint, c_last: ::core::ffi::c_uint) -> bool;
    pub fn ImGuiViewport_ImGuiViewport() -> *mut ImGuiViewport;
    pub fn ImGuiViewport_destroy(self_: *mut ImGuiViewport);
    pub fn ImGuiViewport_GetCenter(self_: *mut ImGuiViewport) -> ImVec2_c;
    pub fn ImGuiViewport_GetWorkCenter(self_: *mut ImGuiViewport) -> ImVec2_c;
    pub fn ImGuiPlatformIO_ImGuiPlatformIO() -> *mut ImGuiPlatformIO;
    pub fn ImGuiPlatformIO_destroy(self_: *mut ImGuiPlatformIO);
    pub fn ImGuiPlatformIO_ClearPlatformHandlers(self_: *mut ImGuiPlatformIO);
    pub fn ImGuiPlatformIO_ClearRendererHandlers(self_: *mut ImGuiPlatformIO);
    pub fn ImGuiPlatformImeData_ImGuiPlatformImeData() -> *mut ImGuiPlatformImeData;
    pub fn ImGuiPlatformImeData_destroy(self_: *mut ImGuiPlatformImeData);
    pub fn igImHashData(data: *const ::core::ffi::c_void, data_size: usize, seed: ImGuiID) -> ImGuiID;
    pub fn igImHashStr(data: *const ::core::ffi::c_char, data_size: usize, seed: ImGuiID) -> ImGuiID;
    pub fn igImHashSkipUncontributingPrefix(label: *const ::core::ffi::c_char) -> *const ::core::ffi::c_char;
    pub fn igImQsort(
        base: *mut ::core::ffi::c_void,
        count: usize,
        size_of_element: usize,
        compare_func: ::core::option::Option<
            unsafe extern "C" fn(arg1: *const ::core::ffi::c_void, arg2: *const ::core::ffi::c_void) -> ::core::ffi::c_int,
        >,
    );
    pub fn igImAlphaBlendColors(col_a: ImU32, col_b: ImU32) -> ImU32;
    pub fn igImIsPowerOfTwo_Int(v: ::core::ffi::c_int) -> bool;
    pub fn igImIsPowerOfTwo_U64(v: ImU64) -> bool;
    pub fn igImUpperPowerOfTwo(v: ::core::ffi::c_int) -> ::core::ffi::c_int;
    pub fn igImCountSetBits(v: ::core::ffi::c_uint) -> ::core::ffi::c_uint;
    pub fn igImStricmp(str1: *const ::core::ffi::c_char, str2: *const ::core::ffi::c_char) -> ::core::ffi::c_int;
    pub fn igImStrnicmp(str1: *const ::core::ffi::c_char, str2: *const ::core::ffi::c_char, count: usize) -> ::core::ffi::c_int;
    pub fn igImStrncpy(dst: *mut ::core::ffi::c_char, src: *const ::core::ffi::c_char, count: usize);
    pub fn igImStrdup(str_: *const ::core::ffi::c_char) -> *mut ::core::ffi::c_char;
    pub fn igImMemdup(src: *const ::core::ffi::c_void, size: usize) -> *mut ::core::ffi::c_void;
    pub fn igImStrdupcpy(
        dst: *mut ::core::ffi::c_char,
        p_dst_size: *mut usize,
        str_: *const ::core::ffi::c_char,
    ) -> *mut ::core::ffi::c_char;
    pub fn igImStrchrRange(
        str_begin: *const ::core::ffi::c_char,
        str_end: *const ::core::ffi::c_char,
        c: ::core::ffi::c_char,
    ) -> *const ::core::ffi::c_char;
    pub fn igImStreolRange(str_: *const ::core::ffi::c_char, str_end: *const ::core::ffi::c_char) -> *const ::core::ffi::c_char;
    pub fn igImStristr(
        haystack: *const ::core::ffi::c_char,
        haystack_end: *const ::core::ffi::c_char,
        needle: *const ::core::ffi::c_char,
        needle_end: *const ::core::ffi::c_char,
    ) -> *const ::core::ffi::c_char;
    pub fn igImStrTrimBlanks(str_: *mut ::core::ffi::c_char);
    pub fn igImStrSkipBlank(str_: *const ::core::ffi::c_char) -> *const ::core::ffi::c_char;
    pub fn igImStrlenW(str_: *const ImWchar) -> ::core::ffi::c_int;
    pub fn igImStrbol(
        buf_mid_line: *const ::core::ffi::c_char,
        buf_begin: *const ::core::ffi::c_char,
    ) -> *const ::core::ffi::c_char;
    pub fn igImToUpper(c: ::core::ffi::c_char) -> ::core::ffi::c_char;
    pub fn igImCharIsBlankA(c: ::core::ffi::c_char) -> bool;
    pub fn igImCharIsBlankW(c: ::core::ffi::c_uint) -> bool;
    pub fn igImCharIsXdigitA(c: ::core::ffi::c_char) -> bool;
    pub fn igImFormatString(
        buf: *mut ::core::ffi::c_char,
        buf_size: usize,
        fmt: *const ::core::ffi::c_char,
        ...
    ) -> ::core::ffi::c_int;
    pub fn igImFormatStringV(
        buf: *mut ::core::ffi::c_char,
        buf_size: usize,
        fmt: *const ::core::ffi::c_char,
        args: va_list,
    ) -> ::core::ffi::c_int;
    pub fn igImFormatStringToTempBuffer(
        out_buf: *mut *const ::core::ffi::c_char,
        out_buf_end: *mut *const ::core::ffi::c_char,
        fmt: *const ::core::ffi::c_char,
        ...
    );
    pub fn igImFormatStringToTempBufferV(
        out_buf: *mut *const ::core::ffi::c_char,
        out_buf_end: *mut *const ::core::ffi::c_char,
        fmt: *const ::core::ffi::c_char,
        args: va_list,
    );
    pub fn igImParseFormatFindStart(format: *const ::core::ffi::c_char) -> *const ::core::ffi::c_char;
    pub fn igImParseFormatFindEnd(format: *const ::core::ffi::c_char) -> *const ::core::ffi::c_char;
    pub fn igImParseFormatTrimDecorations(
        format: *const ::core::ffi::c_char,
        buf: *mut ::core::ffi::c_char,
        buf_size: usize,
    ) -> *const ::core::ffi::c_char;
    pub fn igImParseFormatSanitizeForPrinting(
        fmt_in: *const ::core::ffi::c_char,
        fmt_out: *mut ::core::ffi::c_char,
        fmt_out_size: usize,
    );
    pub fn igImParseFormatSanitizeForScanning(
        fmt_in: *const ::core::ffi::c_char,
        fmt_out: *mut ::core::ffi::c_char,
        fmt_out_size: usize,
    ) -> *const ::core::ffi::c_char;
    pub fn igImParseFormatPrecision(format: *const ::core::ffi::c_char, default_value: ::core::ffi::c_int) -> ::core::ffi::c_int;
    pub fn igImTextCharToUtf8(out_buf: *mut ::core::ffi::c_char, c: ::core::ffi::c_uint) -> ::core::ffi::c_int;
    pub fn igImTextStrToUtf8(
        out_buf: *mut ::core::ffi::c_char,
        out_buf_size: ::core::ffi::c_int,
        in_text: *const ImWchar,
        in_text_end: *const ImWchar,
    ) -> ::core::ffi::c_int;
    pub fn igImTextCharFromUtf8(
        out_char: *mut ::core::ffi::c_uint,
        in_text: *const ::core::ffi::c_char,
        in_text_end: *const ::core::ffi::c_char,
    ) -> ::core::ffi::c_int;
    pub fn igImTextStrFromUtf8(
        out_buf: *mut ImWchar,
        out_buf_size: ::core::ffi::c_int,
        in_text: *const ::core::ffi::c_char,
        in_text_end: *const ::core::ffi::c_char,
        in_remaining: *mut *const ::core::ffi::c_char,
    ) -> ::core::ffi::c_int;
    pub fn igImTextCountCharsFromUtf8(
        in_text: *const ::core::ffi::c_char,
        in_text_end: *const ::core::ffi::c_char,
    ) -> ::core::ffi::c_int;
    pub fn igImTextCountUtf8BytesFromChar(
        in_text: *const ::core::ffi::c_char,
        in_text_end: *const ::core::ffi::c_char,
    ) -> ::core::ffi::c_int;
    pub fn igImTextCountUtf8BytesFromStr(in_text: *const ImWchar, in_text_end: *const ImWchar) -> ::core::ffi::c_int;
    pub fn igImTextFindPreviousUtf8Codepoint(
        in_text_start: *const ::core::ffi::c_char,
        in_p: *const ::core::ffi::c_char,
    ) -> *const ::core::ffi::c_char;
    pub fn igImTextFindValidUtf8CodepointEnd(
        in_text_start: *const ::core::ffi::c_char,
        in_text_end: *const ::core::ffi::c_char,
        in_p: *const ::core::ffi::c_char,
    ) -> *const ::core::ffi::c_char;
    pub fn igImTextCountLines(in_text: *const ::core::ffi::c_char, in_text_end: *const ::core::ffi::c_char)
    -> ::core::ffi::c_int;
    pub fn igImFontCalcTextSizeEx(
        font: *mut ImFont,
        size: f32,
        max_width: f32,
        wrap_width: f32,
        text_begin: *const ::core::ffi::c_char,
        text_end_display: *const ::core::ffi::c_char,
        text_end: *const ::core::ffi::c_char,
        out_remaining: *mut *const ::core::ffi::c_char,
        out_offset: *mut ImVec2_c,
        flags: ImDrawTextFlags,
    ) -> ImVec2_c;
    pub fn igImFontCalcWordWrapPositionEx(
        font: *mut ImFont,
        size: f32,
        text: *const ::core::ffi::c_char,
        text_end: *const ::core::ffi::c_char,
        wrap_width: f32,
        flags: ImDrawTextFlags,
    ) -> *const ::core::ffi::c_char;
    pub fn igImTextCalcWordWrapNextLineStart(
        text: *const ::core::ffi::c_char,
        text_end: *const ::core::ffi::c_char,
        flags: ImDrawTextFlags,
    ) -> *const ::core::ffi::c_char;
    pub fn igImTextInitClassifiers();
    pub fn igImTextClassifierClear(
        bits: *mut ImU32,
        codepoint_min: ::core::ffi::c_uint,
        codepoint_end: ::core::ffi::c_uint,
        char_class: ImWcharClass,
    );
    pub fn igImTextClassifierSetCharClass(
        bits: *mut ImU32,
        codepoint_min: ::core::ffi::c_uint,
        codepoint_end: ::core::ffi::c_uint,
        char_class: ImWcharClass,
        c: ::core::ffi::c_uint,
    );
    pub fn igImTextClassifierSetCharClassFromStr(
        bits: *mut ImU32,
        codepoint_min: ::core::ffi::c_uint,
        codepoint_end: ::core::ffi::c_uint,
        char_class: ImWcharClass,
        s: *const ::core::ffi::c_char,
    );
    pub fn igImFileOpen(filename: *const ::core::ffi::c_char, mode: *const ::core::ffi::c_char) -> ImFileHandle;
    pub fn igImFileClose(file: ImFileHandle) -> bool;
    pub fn igImFileGetSize(file: ImFileHandle) -> ImU64;
    pub fn igImFileRead(data: *mut ::core::ffi::c_void, size: ImU64, count: ImU64, file: ImFileHandle) -> ImU64;
    pub fn igImFileWrite(data: *const ::core::ffi::c_void, size: ImU64, count: ImU64, file: ImFileHandle) -> ImU64;
    pub fn igImFileLoadToMemory(
        filename: *const ::core::ffi::c_char,
        mode: *const ::core::ffi::c_char,
        out_file_size: *mut usize,
        padding_bytes: ::core::ffi::c_int,
    ) -> *mut ::core::ffi::c_void;
    pub fn igImPow_Float(x: f32, y: f32) -> f32;
    pub fn igImPow_double(x: f64, y: f64) -> f64;
    pub fn igImLog_Float(x: f32) -> f32;
    pub fn igImLog_double(x: f64) -> f64;
    pub fn igImAbs_Int(x: ::core::ffi::c_int) -> ::core::ffi::c_int;
    pub fn igImAbs_Float(x: f32) -> f32;
    pub fn igImAbs_double(x: f64) -> f64;
    pub fn igImSign_Float(x: f32) -> f32;
    pub fn igImSign_double(x: f64) -> f64;
    pub fn igImRsqrt_Float(x: f32) -> f32;
    pub fn igImRsqrt_double(x: f64) -> f64;
    pub fn igImMin(lhs: ImVec2_c, rhs: ImVec2_c) -> ImVec2_c;
    pub fn igImMax(lhs: ImVec2_c, rhs: ImVec2_c) -> ImVec2_c;
    pub fn igImClamp(v: ImVec2_c, mn: ImVec2_c, mx: ImVec2_c) -> ImVec2_c;
    pub fn igImLerp_Vec2Float(a: ImVec2_c, b: ImVec2_c, t: f32) -> ImVec2_c;
    pub fn igImLerp_Vec2Vec2(a: ImVec2_c, b: ImVec2_c, t: ImVec2_c) -> ImVec2_c;
    pub fn igImLerp_Vec4(a: ImVec4_c, b: ImVec4_c, t: f32) -> ImVec4_c;
    pub fn igImSaturate(f: f32) -> f32;
    pub fn igImLengthSqr_Vec2(lhs: ImVec2_c) -> f32;
    pub fn igImLengthSqr_Vec4(lhs: ImVec4_c) -> f32;
    pub fn igImInvLength(lhs: ImVec2_c, fail_value: f32) -> f32;
    pub fn igImTrunc_Float(f: f32) -> f32;
    pub fn igImTrunc_Vec2(v: ImVec2_c) -> ImVec2_c;
    pub fn igImFloor_Float(f: f32) -> f32;
    pub fn igImFloor_Vec2(v: ImVec2_c) -> ImVec2_c;
    pub fn igImTrunc64(f: f32) -> f32;
    pub fn igImRound64(f: f32) -> f32;
    pub fn igImModPositive(a: ::core::ffi::c_int, b: ::core::ffi::c_int) -> ::core::ffi::c_int;
    pub fn igImDot(a: ImVec2_c, b: ImVec2_c) -> f32;
    pub fn igImRotate(v: ImVec2_c, cos_a: f32, sin_a: f32) -> ImVec2_c;
    pub fn igImLinearSweep(current: f32, target: f32, speed: f32) -> f32;
    pub fn igImLinearRemapClamp(s0: f32, s1: f32, d0: f32, d1: f32, x: f32) -> f32;
    pub fn igImMul(lhs: ImVec2_c, rhs: ImVec2_c) -> ImVec2_c;
    pub fn igImIsFloatAboveGuaranteedIntegerPrecision(f: f32) -> bool;
    pub fn igImExponentialMovingAverage(avg: f32, sample: f32, n: ::core::ffi::c_int) -> f32;
    pub fn igImBezierCubicCalc(p1: ImVec2_c, p2: ImVec2_c, p3: ImVec2_c, p4: ImVec2_c, t: f32) -> ImVec2_c;
    pub fn igImBezierCubicClosestPoint(
        p1: ImVec2_c,
        p2: ImVec2_c,
        p3: ImVec2_c,
        p4: ImVec2_c,
        p: ImVec2_c,
        num_segments: ::core::ffi::c_int,
    ) -> ImVec2_c;
    pub fn igImBezierCubicClosestPointCasteljau(
        p1: ImVec2_c,
        p2: ImVec2_c,
        p3: ImVec2_c,
        p4: ImVec2_c,
        p: ImVec2_c,
        tess_tol: f32,
    ) -> ImVec2_c;
    pub fn igImBezierQuadraticCalc(p1: ImVec2_c, p2: ImVec2_c, p3: ImVec2_c, t: f32) -> ImVec2_c;
    pub fn igImLineClosestPoint(a: ImVec2_c, b: ImVec2_c, p: ImVec2_c) -> ImVec2_c;
    pub fn igImTriangleContainsPoint(a: ImVec2_c, b: ImVec2_c, c: ImVec2_c, p: ImVec2_c) -> bool;
    pub fn igImTriangleClosestPoint(a: ImVec2_c, b: ImVec2_c, c: ImVec2_c, p: ImVec2_c) -> ImVec2_c;
    pub fn igImTriangleBarycentricCoords(
        a: ImVec2_c,
        b: ImVec2_c,
        c: ImVec2_c,
        p: ImVec2_c,
        out_u: *mut f32,
        out_v: *mut f32,
        out_w: *mut f32,
    );
    pub fn igImTriangleArea(a: ImVec2_c, b: ImVec2_c, c: ImVec2_c) -> f32;
    pub fn igImTriangleIsClockwise(a: ImVec2_c, b: ImVec2_c, c: ImVec2_c) -> bool;
    pub fn ImVec1_ImVec1_Nil() -> *mut ImVec1;
    pub fn ImVec1_destroy(self_: *mut ImVec1);
    pub fn ImVec1_ImVec1_Float(_x: f32) -> *mut ImVec1;
    pub fn ImVec2i_ImVec2i_Nil() -> *mut ImVec2i;
    pub fn ImVec2i_destroy(self_: *mut ImVec2i);
    pub fn ImVec2i_ImVec2i_Int(_x: ::core::ffi::c_int, _y: ::core::ffi::c_int) -> *mut ImVec2i;
    pub fn ImVec2ih_ImVec2ih_Nil() -> *mut ImVec2ih;
    pub fn ImVec2ih_destroy(self_: *mut ImVec2ih);
    pub fn ImVec2ih_ImVec2ih_short(_x: ::core::ffi::c_short, _y: ::core::ffi::c_short) -> *mut ImVec2ih;
    pub fn ImVec2ih_ImVec2ih_Vec2(rhs: ImVec2_c) -> *mut ImVec2ih;
    pub fn ImRect_ImRect_Nil() -> *mut ImRect;
    pub fn ImRect_destroy(self_: *mut ImRect);
    pub fn ImRect_ImRect_Vec2(min: ImVec2_c, max: ImVec2_c) -> *mut ImRect;
    pub fn ImRect_ImRect_Vec4(v: ImVec4_c) -> *mut ImRect;
    pub fn ImRect_ImRect_Float(x1: f32, y1: f32, x2: f32, y2: f32) -> *mut ImRect;
    pub fn ImRect_GetCenter(self_: *mut ImRect) -> ImVec2_c;
    pub fn ImRect_GetSize(self_: *mut ImRect) -> ImVec2_c;
    pub fn ImRect_GetWidth(self_: *mut ImRect) -> f32;
    pub fn ImRect_GetHeight(self_: *mut ImRect) -> f32;
    pub fn ImRect_GetArea(self_: *mut ImRect) -> f32;
    pub fn ImRect_GetTL(self_: *mut ImRect) -> ImVec2_c;
    pub fn ImRect_GetTR(self_: *mut ImRect) -> ImVec2_c;
    pub fn ImRect_GetBL(self_: *mut ImRect) -> ImVec2_c;
    pub fn ImRect_GetBR(self_: *mut ImRect) -> ImVec2_c;
    pub fn ImRect_Contains_Vec2(self_: *mut ImRect, p: ImVec2_c) -> bool;
    pub fn ImRect_Contains_Rect(self_: *mut ImRect, r: ImRect_c) -> bool;
    pub fn ImRect_ContainsWithPad(self_: *mut ImRect, p: ImVec2_c, pad: ImVec2_c) -> bool;
    pub fn ImRect_Overlaps(self_: *mut ImRect, r: ImRect_c) -> bool;
    pub fn ImRect_Add_Vec2(self_: *mut ImRect, p: ImVec2_c);
    pub fn ImRect_Add_Rect(self_: *mut ImRect, r: ImRect_c);
    pub fn ImRect_AddX(self_: *mut ImRect, x: f32);
    pub fn ImRect_AddY(self_: *mut ImRect, y: f32);
    pub fn ImRect_Expand_Float(self_: *mut ImRect, amount: f32);
    pub fn ImRect_Expand_Vec2(self_: *mut ImRect, amount: ImVec2_c);
    pub fn ImRect_Translate(self_: *mut ImRect, d: ImVec2_c);
    pub fn ImRect_TranslateX(self_: *mut ImRect, dx: f32);
    pub fn ImRect_TranslateY(self_: *mut ImRect, dy: f32);
    pub fn ImRect_ClipWith(self_: *mut ImRect, r: ImRect_c);
    pub fn ImRect_ClipWithFull(self_: *mut ImRect, r: ImRect_c);
    pub fn ImRect_IsInverted(self_: *mut ImRect) -> bool;
    pub fn ImRect_ToVec4(self_: *mut ImRect) -> ImVec4_c;
    pub fn ImRect_AsVec4(self_: *mut ImRect) -> *const ImVec4_c;
    pub fn igImBitArrayGetStorageSizeInBytes(bitcount: ::core::ffi::c_int) -> usize;
    pub fn igImBitArrayClearAllBits(arr: *mut ImU32, bitcount: ::core::ffi::c_int);
    pub fn igImBitArrayTestBit(arr: *const ImU32, n: ::core::ffi::c_int) -> bool;
    pub fn igImBitArrayClearBit(arr: *mut ImU32, n: ::core::ffi::c_int);
    pub fn igImBitArraySetBit(arr: *mut ImU32, n: ::core::ffi::c_int);
    pub fn igImBitArraySetBitRange(arr: *mut ImU32, n: ::core::ffi::c_int, n2: ::core::ffi::c_int);
    pub fn ImBitVector_Create(self_: *mut ImBitVector, sz: ::core::ffi::c_int);
    pub fn ImBitVector_Clear(self_: *mut ImBitVector);
    pub fn ImBitVector_TestBit(self_: *mut ImBitVector, n: ::core::ffi::c_int) -> bool;
    pub fn ImBitVector_SetBit(self_: *mut ImBitVector, n: ::core::ffi::c_int);
    pub fn ImBitVector_ClearBit(self_: *mut ImBitVector, n: ::core::ffi::c_int);
    pub fn ImGuiTextIndex_clear(self_: *mut ImGuiTextIndex);
    pub fn ImGuiTextIndex_size(self_: *mut ImGuiTextIndex) -> ::core::ffi::c_int;
    pub fn ImGuiTextIndex_get_line_begin(
        self_: *mut ImGuiTextIndex,
        base: *const ::core::ffi::c_char,
        n: ::core::ffi::c_int,
    ) -> *const ::core::ffi::c_char;
    pub fn ImGuiTextIndex_get_line_end(
        self_: *mut ImGuiTextIndex,
        base: *const ::core::ffi::c_char,
        n: ::core::ffi::c_int,
    ) -> *const ::core::ffi::c_char;
    pub fn ImGuiTextIndex_append(
        self_: *mut ImGuiTextIndex,
        base: *const ::core::ffi::c_char,
        old_size: ::core::ffi::c_int,
        new_size: ::core::ffi::c_int,
    );
    pub fn igImLowerBound(in_begin: *mut ImGuiStoragePair, in_end: *mut ImGuiStoragePair, key: ImGuiID) -> *mut ImGuiStoragePair;
    pub fn ImDrawListSharedData_ImDrawListSharedData() -> *mut ImDrawListSharedData;
    pub fn ImDrawListSharedData_destroy(self_: *mut ImDrawListSharedData);
    pub fn ImDrawListSharedData_SetCircleTessellationMaxError(self_: *mut ImDrawListSharedData, max_error: f32);
    pub fn ImDrawDataBuilder_ImDrawDataBuilder() -> *mut ImDrawDataBuilder;
    pub fn ImDrawDataBuilder_destroy(self_: *mut ImDrawDataBuilder);
    pub fn ImGuiStyleVarInfo_GetVarPtr(
        self_: *mut ImGuiStyleVarInfo,
        parent: *mut ::core::ffi::c_void,
    ) -> *mut ::core::ffi::c_void;
    pub fn ImGuiStyleMod_ImGuiStyleMod_Int(idx: ImGuiStyleVar, v: ::core::ffi::c_int) -> *mut ImGuiStyleMod;
    pub fn ImGuiStyleMod_destroy(self_: *mut ImGuiStyleMod);
    pub fn ImGuiStyleMod_ImGuiStyleMod_Float(idx: ImGuiStyleVar, v: f32) -> *mut ImGuiStyleMod;
    pub fn ImGuiStyleMod_ImGuiStyleMod_Vec2(idx: ImGuiStyleVar, v: ImVec2_c) -> *mut ImGuiStyleMod;
    pub fn ImGuiComboPreviewData_ImGuiComboPreviewData() -> *mut ImGuiComboPreviewData;
    pub fn ImGuiComboPreviewData_destroy(self_: *mut ImGuiComboPreviewData);
    pub fn ImGuiMenuColumns_ImGuiMenuColumns() -> *mut ImGuiMenuColumns;
    pub fn ImGuiMenuColumns_destroy(self_: *mut ImGuiMenuColumns);
    pub fn ImGuiMenuColumns_Update(self_: *mut ImGuiMenuColumns, spacing: f32, window_reappearing: bool);
    pub fn ImGuiMenuColumns_DeclColumns(
        self_: *mut ImGuiMenuColumns,
        w_icon: f32,
        w_label: f32,
        w_shortcut: f32,
        w_mark: f32,
    ) -> f32;
    pub fn ImGuiMenuColumns_CalcNextTotalWidth(self_: *mut ImGuiMenuColumns, update_offsets: bool);
    pub fn ImGuiInputTextDeactivatedState_ImGuiInputTextDeactivatedState() -> *mut ImGuiInputTextDeactivatedState;
    pub fn ImGuiInputTextDeactivatedState_destroy(self_: *mut ImGuiInputTextDeactivatedState);
    pub fn ImGuiInputTextDeactivatedState_ClearFreeMemory(self_: *mut ImGuiInputTextDeactivatedState);
    pub fn ImGuiInputTextState_ImGuiInputTextState() -> *mut ImGuiInputTextState;
    pub fn ImGuiInputTextState_destroy(self_: *mut ImGuiInputTextState);
    pub fn ImGuiInputTextState_ClearText(self_: *mut ImGuiInputTextState);
    pub fn ImGuiInputTextState_ClearFreeMemory(self_: *mut ImGuiInputTextState);
    pub fn ImGuiInputTextState_OnKeyPressed(self_: *mut ImGuiInputTextState, key: ::core::ffi::c_int);
    pub fn ImGuiInputTextState_OnCharPressed(self_: *mut ImGuiInputTextState, c: ::core::ffi::c_uint);
    pub fn ImGuiInputTextState_GetPreferredOffsetX(self_: *mut ImGuiInputTextState) -> f32;
    pub fn ImGuiInputTextState_GetText(self_: *mut ImGuiInputTextState) -> *const ::core::ffi::c_char;
    pub fn ImGuiInputTextState_CursorAnimReset(self_: *mut ImGuiInputTextState);
    pub fn ImGuiInputTextState_CursorClamp(self_: *mut ImGuiInputTextState);
    pub fn ImGuiInputTextState_HasSelection(self_: *mut ImGuiInputTextState) -> bool;
    pub fn ImGuiInputTextState_ClearSelection(self_: *mut ImGuiInputTextState);
    pub fn ImGuiInputTextState_GetCursorPos(self_: *mut ImGuiInputTextState) -> ::core::ffi::c_int;
    pub fn ImGuiInputTextState_GetSelectionStart(self_: *mut ImGuiInputTextState) -> ::core::ffi::c_int;
    pub fn ImGuiInputTextState_GetSelectionEnd(self_: *mut ImGuiInputTextState) -> ::core::ffi::c_int;
    pub fn ImGuiInputTextState_SetSelection(self_: *mut ImGuiInputTextState, start: ::core::ffi::c_int, end: ::core::ffi::c_int);
    pub fn ImGuiInputTextState_SelectAll(self_: *mut ImGuiInputTextState);
    pub fn ImGuiInputTextState_ReloadUserBufAndSelectAll(self_: *mut ImGuiInputTextState);
    pub fn ImGuiInputTextState_ReloadUserBufAndKeepSelection(self_: *mut ImGuiInputTextState);
    pub fn ImGuiInputTextState_ReloadUserBufAndMoveToEnd(self_: *mut ImGuiInputTextState);
    pub fn ImGuiNextWindowData_ImGuiNextWindowData() -> *mut ImGuiNextWindowData;
    pub fn ImGuiNextWindowData_destroy(self_: *mut ImGuiNextWindowData);
    pub fn ImGuiNextWindowData_ClearFlags(self_: *mut ImGuiNextWindowData);
    pub fn ImGuiNextItemData_ImGuiNextItemData() -> *mut ImGuiNextItemData;
    pub fn ImGuiNextItemData_destroy(self_: *mut ImGuiNextItemData);
    pub fn ImGuiNextItemData_ClearFlags(self_: *mut ImGuiNextItemData);
    pub fn ImGuiLastItemData_ImGuiLastItemData() -> *mut ImGuiLastItemData;
    pub fn ImGuiLastItemData_destroy(self_: *mut ImGuiLastItemData);
    pub fn ImGuiErrorRecoveryState_ImGuiErrorRecoveryState() -> *mut ImGuiErrorRecoveryState;
    pub fn ImGuiErrorRecoveryState_destroy(self_: *mut ImGuiErrorRecoveryState);
    pub fn ImGuiPtrOrIndex_ImGuiPtrOrIndex_Ptr(ptr: *mut ::core::ffi::c_void) -> *mut ImGuiPtrOrIndex;
    pub fn ImGuiPtrOrIndex_destroy(self_: *mut ImGuiPtrOrIndex);
    pub fn ImGuiPtrOrIndex_ImGuiPtrOrIndex_Int(index: ::core::ffi::c_int) -> *mut ImGuiPtrOrIndex;
    pub fn ImGuiPopupData_ImGuiPopupData() -> *mut ImGuiPopupData;
    pub fn ImGuiPopupData_destroy(self_: *mut ImGuiPopupData);
    pub fn ImGuiInputEvent_ImGuiInputEvent() -> *mut ImGuiInputEvent;
    pub fn ImGuiInputEvent_destroy(self_: *mut ImGuiInputEvent);
    pub fn ImGuiKeyRoutingData_ImGuiKeyRoutingData() -> *mut ImGuiKeyRoutingData;
    pub fn ImGuiKeyRoutingData_destroy(self_: *mut ImGuiKeyRoutingData);
    pub fn ImGuiKeyRoutingTable_ImGuiKeyRoutingTable() -> *mut ImGuiKeyRoutingTable;
    pub fn ImGuiKeyRoutingTable_destroy(self_: *mut ImGuiKeyRoutingTable);
    pub fn ImGuiKeyRoutingTable_Clear(self_: *mut ImGuiKeyRoutingTable);
    pub fn ImGuiKeyOwnerData_ImGuiKeyOwnerData() -> *mut ImGuiKeyOwnerData;
    pub fn ImGuiKeyOwnerData_destroy(self_: *mut ImGuiKeyOwnerData);
    pub fn ImGuiListClipperRange_FromIndices(min: ::core::ffi::c_int, max: ::core::ffi::c_int) -> ImGuiListClipperRange;
    pub fn ImGuiListClipperRange_FromPositions(
        y1: f32,
        y2: f32,
        off_min: ::core::ffi::c_int,
        off_max: ::core::ffi::c_int,
    ) -> ImGuiListClipperRange;
    pub fn ImGuiListClipperData_ImGuiListClipperData() -> *mut ImGuiListClipperData;
    pub fn ImGuiListClipperData_destroy(self_: *mut ImGuiListClipperData);
    pub fn ImGuiListClipperData_Reset(self_: *mut ImGuiListClipperData, clipper: *mut ImGuiListClipper);
    pub fn ImGuiNavItemData_ImGuiNavItemData() -> *mut ImGuiNavItemData;
    pub fn ImGuiNavItemData_destroy(self_: *mut ImGuiNavItemData);
    pub fn ImGuiNavItemData_Clear(self_: *mut ImGuiNavItemData);
    pub fn ImGuiTypingSelectState_ImGuiTypingSelectState() -> *mut ImGuiTypingSelectState;
    pub fn ImGuiTypingSelectState_destroy(self_: *mut ImGuiTypingSelectState);
    pub fn ImGuiTypingSelectState_Clear(self_: *mut ImGuiTypingSelectState);
    pub fn ImGuiOldColumnData_ImGuiOldColumnData() -> *mut ImGuiOldColumnData;
    pub fn ImGuiOldColumnData_destroy(self_: *mut ImGuiOldColumnData);
    pub fn ImGuiOldColumns_ImGuiOldColumns() -> *mut ImGuiOldColumns;
    pub fn ImGuiOldColumns_destroy(self_: *mut ImGuiOldColumns);
    pub fn ImGuiBoxSelectState_ImGuiBoxSelectState() -> *mut ImGuiBoxSelectState;
    pub fn ImGuiBoxSelectState_destroy(self_: *mut ImGuiBoxSelectState);
    pub fn ImGuiMultiSelectTempData_ImGuiMultiSelectTempData() -> *mut ImGuiMultiSelectTempData;
    pub fn ImGuiMultiSelectTempData_destroy(self_: *mut ImGuiMultiSelectTempData);
    pub fn ImGuiMultiSelectTempData_Clear(self_: *mut ImGuiMultiSelectTempData);
    pub fn ImGuiMultiSelectTempData_ClearIO(self_: *mut ImGuiMultiSelectTempData);
    pub fn ImGuiMultiSelectState_ImGuiMultiSelectState() -> *mut ImGuiMultiSelectState;
    pub fn ImGuiMultiSelectState_destroy(self_: *mut ImGuiMultiSelectState);
    pub fn ImGuiViewportP_ImGuiViewportP() -> *mut ImGuiViewportP;
    pub fn ImGuiViewportP_destroy(self_: *mut ImGuiViewportP);
    pub fn ImGuiViewportP_CalcWorkRectPos(self_: *mut ImGuiViewportP, inset_min: ImVec2_c) -> ImVec2_c;
    pub fn ImGuiViewportP_CalcWorkRectSize(self_: *mut ImGuiViewportP, inset_min: ImVec2_c, inset_max: ImVec2_c) -> ImVec2_c;
    pub fn ImGuiViewportP_UpdateWorkRect(self_: *mut ImGuiViewportP);
    pub fn ImGuiViewportP_GetMainRect(self_: *mut ImGuiViewportP) -> ImRect_c;
    pub fn ImGuiViewportP_GetWorkRect(self_: *mut ImGuiViewportP) -> ImRect_c;
    pub fn ImGuiViewportP_GetBuildWorkRect(self_: *mut ImGuiViewportP) -> ImRect_c;
    pub fn ImGuiWindowSettings_ImGuiWindowSettings() -> *mut ImGuiWindowSettings;
    pub fn ImGuiWindowSettings_destroy(self_: *mut ImGuiWindowSettings);
    pub fn ImGuiWindowSettings_GetName(self_: *mut ImGuiWindowSettings) -> *mut ::core::ffi::c_char;
    pub fn ImGuiSettingsHandler_ImGuiSettingsHandler() -> *mut ImGuiSettingsHandler;
    pub fn ImGuiSettingsHandler_destroy(self_: *mut ImGuiSettingsHandler);
    pub fn ImGuiDebugAllocInfo_ImGuiDebugAllocInfo() -> *mut ImGuiDebugAllocInfo;
    pub fn ImGuiDebugAllocInfo_destroy(self_: *mut ImGuiDebugAllocInfo);
    pub fn ImGuiStackLevelInfo_ImGuiStackLevelInfo() -> *mut ImGuiStackLevelInfo;
    pub fn ImGuiStackLevelInfo_destroy(self_: *mut ImGuiStackLevelInfo);
    pub fn ImGuiDebugItemPathQuery_ImGuiDebugItemPathQuery() -> *mut ImGuiDebugItemPathQuery;
    pub fn ImGuiDebugItemPathQuery_destroy(self_: *mut ImGuiDebugItemPathQuery);
    pub fn ImGuiIDStackTool_ImGuiIDStackTool() -> *mut ImGuiIDStackTool;
    pub fn ImGuiIDStackTool_destroy(self_: *mut ImGuiIDStackTool);
    pub fn ImGuiContextHook_ImGuiContextHook() -> *mut ImGuiContextHook;
    pub fn ImGuiContextHook_destroy(self_: *mut ImGuiContextHook);
    pub fn ImGuiContext_ImGuiContext(shared_font_atlas: *mut ImFontAtlas) -> *mut ImGuiContext;
    pub fn ImGuiContext_destroy(self_: *mut ImGuiContext);
    pub fn ImGuiWindow_ImGuiWindow(context: *mut ImGuiContext, name: *const ::core::ffi::c_char) -> *mut ImGuiWindow;
    pub fn ImGuiWindow_destroy(self_: *mut ImGuiWindow);
    pub fn ImGuiWindow_GetID_Str(
        self_: *mut ImGuiWindow,
        str_: *const ::core::ffi::c_char,
        str_end: *const ::core::ffi::c_char,
    ) -> ImGuiID;
    pub fn ImGuiWindow_GetID_Ptr(self_: *mut ImGuiWindow, ptr: *const ::core::ffi::c_void) -> ImGuiID;
    pub fn ImGuiWindow_GetID_Int(self_: *mut ImGuiWindow, n: ::core::ffi::c_int) -> ImGuiID;
    pub fn ImGuiWindow_GetIDFromPos(self_: *mut ImGuiWindow, p_abs: ImVec2_c) -> ImGuiID;
    pub fn ImGuiWindow_GetIDFromRectangle(self_: *mut ImGuiWindow, r_abs: ImRect_c) -> ImGuiID;
    pub fn ImGuiWindow_Rect(self_: *mut ImGuiWindow) -> ImRect_c;
    pub fn ImGuiWindow_TitleBarRect(self_: *mut ImGuiWindow) -> ImRect_c;
    pub fn ImGuiWindow_MenuBarRect(self_: *mut ImGuiWindow) -> ImRect_c;
    pub fn ImGuiTabItem_ImGuiTabItem() -> *mut ImGuiTabItem;
    pub fn ImGuiTabItem_destroy(self_: *mut ImGuiTabItem);
    pub fn ImGuiTabBar_ImGuiTabBar() -> *mut ImGuiTabBar;
    pub fn ImGuiTabBar_destroy(self_: *mut ImGuiTabBar);
    pub fn ImGuiTableColumn_ImGuiTableColumn() -> *mut ImGuiTableColumn;
    pub fn ImGuiTableColumn_destroy(self_: *mut ImGuiTableColumn);
    pub fn ImGuiTableInstanceData_ImGuiTableInstanceData() -> *mut ImGuiTableInstanceData;
    pub fn ImGuiTableInstanceData_destroy(self_: *mut ImGuiTableInstanceData);
    pub fn ImGuiTable_ImGuiTable() -> *mut ImGuiTable;
    pub fn ImGuiTable_destroy(self_: *mut ImGuiTable);
    pub fn ImGuiTableTempData_ImGuiTableTempData() -> *mut ImGuiTableTempData;
    pub fn ImGuiTableTempData_destroy(self_: *mut ImGuiTableTempData);
    pub fn ImGuiTableColumnSettings_ImGuiTableColumnSettings() -> *mut ImGuiTableColumnSettings;
    pub fn ImGuiTableColumnSettings_destroy(self_: *mut ImGuiTableColumnSettings);
    pub fn ImGuiTableSettings_ImGuiTableSettings() -> *mut ImGuiTableSettings;
    pub fn ImGuiTableSettings_destroy(self_: *mut ImGuiTableSettings);
    pub fn ImGuiTableSettings_GetColumnSettings(self_: *mut ImGuiTableSettings) -> *mut ImGuiTableColumnSettings;
    pub fn igGetIO_ContextPtr(ctx: *mut ImGuiContext) -> *mut ImGuiIO;
    pub fn igGetPlatformIO_ContextPtr(ctx: *mut ImGuiContext) -> *mut ImGuiPlatformIO;
    pub fn igGetScale() -> f32;
    pub fn igGetCurrentWindowRead() -> *mut ImGuiWindow;
    pub fn igGetCurrentWindow() -> *mut ImGuiWindow;
    pub fn igFindWindowByID(id: ImGuiID) -> *mut ImGuiWindow;
    pub fn igFindWindowByName(name: *const ::core::ffi::c_char) -> *mut ImGuiWindow;
    pub fn igUpdateWindowParentAndRootLinks(window: *mut ImGuiWindow, flags: ImGuiWindowFlags, parent_window: *mut ImGuiWindow);
    pub fn igUpdateWindowSkipRefresh(window: *mut ImGuiWindow);
    pub fn igCalcWindowNextAutoFitSize(window: *mut ImGuiWindow) -> ImVec2_c;
    pub fn igIsWindowChildOf(window: *mut ImGuiWindow, potential_parent: *mut ImGuiWindow, popup_hierarchy: bool) -> bool;
    pub fn igIsWindowInBeginStack(window: *mut ImGuiWindow) -> bool;
    pub fn igIsWindowWithinBeginStackOf(window: *mut ImGuiWindow, potential_parent: *mut ImGuiWindow) -> bool;
    pub fn igIsWindowAbove(potential_above: *mut ImGuiWindow, potential_below: *mut ImGuiWindow) -> bool;
    pub fn igIsWindowNavFocusable(window: *mut ImGuiWindow) -> bool;
    pub fn igSetWindowPos_WindowPtr(window: *mut ImGuiWindow, pos: ImVec2_c, cond: ImGuiCond);
    pub fn igSetWindowSize_WindowPtr(window: *mut ImGuiWindow, size: ImVec2_c, cond: ImGuiCond);
    pub fn igSetWindowCollapsed_WindowPtr(window: *mut ImGuiWindow, collapsed: bool, cond: ImGuiCond);
    pub fn igSetWindowHitTestHole(window: *mut ImGuiWindow, pos: ImVec2_c, size: ImVec2_c);
    pub fn igSetWindowHiddenAndSkipItemsForCurrentFrame(window: *mut ImGuiWindow);
    pub fn igSetWindowParentWindowForFocusRoute(window: *mut ImGuiWindow, parent_window: *mut ImGuiWindow);
    pub fn igWindowRectAbsToRel(window: *mut ImGuiWindow, r: ImRect_c) -> ImRect_c;
    pub fn igWindowRectRelToAbs(window: *mut ImGuiWindow, r: ImRect_c) -> ImRect_c;
    pub fn igWindowPosAbsToRel(window: *mut ImGuiWindow, p: ImVec2_c) -> ImVec2_c;
    pub fn igWindowPosRelToAbs(window: *mut ImGuiWindow, p: ImVec2_c) -> ImVec2_c;
    pub fn igFocusWindow(window: *mut ImGuiWindow, flags: ImGuiFocusRequestFlags);
    pub fn igFocusTopMostWindowUnderOne(
        under_this_window: *mut ImGuiWindow,
        ignore_window: *mut ImGuiWindow,
        filter_viewport: *mut ImGuiViewport,
        flags: ImGuiFocusRequestFlags,
    );
    pub fn igBringWindowToFocusFront(window: *mut ImGuiWindow);
    pub fn igBringWindowToDisplayFront(window: *mut ImGuiWindow);
    pub fn igBringWindowToDisplayBack(window: *mut ImGuiWindow);
    pub fn igBringWindowToDisplayBehind(window: *mut ImGuiWindow, above_window: *mut ImGuiWindow);
    pub fn igFindWindowDisplayIndex(window: *mut ImGuiWindow) -> ::core::ffi::c_int;
    pub fn igFindBottomMostVisibleWindowWithinBeginStack(window: *mut ImGuiWindow) -> *mut ImGuiWindow;
    pub fn igSetNextWindowRefreshPolicy(flags: ImGuiWindowRefreshFlags);
    pub fn igRegisterUserTexture(tex: *mut ImTextureData);
    pub fn igUnregisterUserTexture(tex: *mut ImTextureData);
    pub fn igRegisterFontAtlas(atlas: *mut ImFontAtlas);
    pub fn igUnregisterFontAtlas(atlas: *mut ImFontAtlas);
    pub fn igSetCurrentFont(font: *mut ImFont, font_size_before_scaling: f32, font_size_after_scaling: f32);
    pub fn igUpdateCurrentFontSize(restore_font_size_after_scaling: f32);
    pub fn igSetFontRasterizerDensity(rasterizer_density: f32);
    pub fn igGetFontRasterizerDensity() -> f32;
    pub fn igGetRoundedFontSize(size: f32) -> f32;
    pub fn igGetDefaultFont() -> *mut ImFont;
    pub fn igPushPasswordFont();
    pub fn igPopPasswordFont();
    pub fn igGetForegroundDrawList_WindowPtr(window: *mut ImGuiWindow) -> *mut ImDrawList;
    pub fn igGetBackgroundDrawList_ViewportPtr(viewport: *mut ImGuiViewport) -> *mut ImDrawList;
    pub fn igGetForegroundDrawList_ViewportPtr(viewport: *mut ImGuiViewport) -> *mut ImDrawList;
    pub fn igAddDrawListToDrawDataEx(
        draw_data: *mut ImDrawData,
        out_list: *mut ImVector_ImDrawListPtr,
        draw_list: *mut ImDrawList,
    );
    pub fn igInitialize();
    pub fn igShutdown();
    pub fn igSetContextName(ctx: *mut ImGuiContext, name: *const ::core::ffi::c_char);
    pub fn igAddContextHook(ctx: *mut ImGuiContext, hook: *const ImGuiContextHook) -> ImGuiID;
    pub fn igRemoveContextHook(ctx: *mut ImGuiContext, hook_to_remove: ImGuiID);
    pub fn igCallContextHooks(ctx: *mut ImGuiContext, type_: ImGuiContextHookType);
    pub fn igUpdateInputEvents(trickle_fast_inputs: bool);
    pub fn igUpdateHoveredWindowAndCaptureFlags(mouse_pos: ImVec2_c);
    pub fn igFindHoveredWindowEx(
        pos: ImVec2_c,
        find_first_and_in_any_viewport: bool,
        out_hovered_window: *mut *mut ImGuiWindow,
        out_hovered_window_under_moving_window: *mut *mut ImGuiWindow,
    );
    pub fn igStartMouseMovingWindow(window: *mut ImGuiWindow);
    pub fn igStopMouseMovingWindow();
    pub fn igUpdateMouseMovingWindowNewFrame();
    pub fn igUpdateMouseMovingWindowEndFrame();
    pub fn igGetWindowViewport() -> *mut ImGuiViewport;
    pub fn igScaleWindowsInViewport(viewport: *mut ImGuiViewportP, scale: f32);
    pub fn igSetWindowViewport(window: *mut ImGuiWindow, viewport: *mut ImGuiViewportP);
    pub fn igMarkIniSettingsDirty_Nil();
    pub fn igMarkIniSettingsDirty_WindowPtr(window: *mut ImGuiWindow);
    pub fn igClearIniSettings();
    pub fn igAddSettingsHandler(handler: *const ImGuiSettingsHandler);
    pub fn igRemoveSettingsHandler(type_name: *const ::core::ffi::c_char);
    pub fn igFindSettingsHandler(type_name: *const ::core::ffi::c_char) -> *mut ImGuiSettingsHandler;
    pub fn igCreateNewWindowSettings(name: *const ::core::ffi::c_char) -> *mut ImGuiWindowSettings;
    pub fn igFindWindowSettingsByID(id: ImGuiID) -> *mut ImGuiWindowSettings;
    pub fn igFindWindowSettingsByWindow(window: *mut ImGuiWindow) -> *mut ImGuiWindowSettings;
    pub fn igClearWindowSettings(name: *const ::core::ffi::c_char);
    pub fn igLocalizeRegisterEntries(entries: *const ImGuiLocEntry, count: ::core::ffi::c_int);
    pub fn igLocalizeGetMsg(key: ImGuiLocKey) -> *const ::core::ffi::c_char;
    pub fn igSetScrollX_WindowPtr(window: *mut ImGuiWindow, scroll_x: f32);
    pub fn igSetScrollY_WindowPtr(window: *mut ImGuiWindow, scroll_y: f32);
    pub fn igSetScrollFromPosX_WindowPtr(window: *mut ImGuiWindow, local_x: f32, center_x_ratio: f32);
    pub fn igSetScrollFromPosY_WindowPtr(window: *mut ImGuiWindow, local_y: f32, center_y_ratio: f32);
    pub fn igScrollToItem(flags: ImGuiScrollFlags);
    pub fn igScrollToRect(window: *mut ImGuiWindow, rect: ImRect_c, flags: ImGuiScrollFlags);
    pub fn igScrollToRectEx(window: *mut ImGuiWindow, rect: ImRect_c, flags: ImGuiScrollFlags) -> ImVec2_c;
    pub fn igScrollToBringRectIntoView(window: *mut ImGuiWindow, rect: ImRect_c);
    pub fn igGetItemStatusFlags() -> ImGuiItemStatusFlags;
    pub fn igGetActiveID() -> ImGuiID;
    pub fn igGetFocusID() -> ImGuiID;
    pub fn igSetActiveID(id: ImGuiID, window: *mut ImGuiWindow);
    pub fn igSetFocusID(id: ImGuiID, window: *mut ImGuiWindow);
    pub fn igClearActiveID();
    pub fn igGetHoveredID() -> ImGuiID;
    pub fn igSetHoveredID(id: ImGuiID);
    pub fn igKeepAliveID(id: ImGuiID);
    pub fn igMarkItemEdited(id: ImGuiID);
    pub fn igPushOverrideID(id: ImGuiID);
    pub fn igGetIDWithSeed_Str(
        str_id_begin: *const ::core::ffi::c_char,
        str_id_end: *const ::core::ffi::c_char,
        seed: ImGuiID,
    ) -> ImGuiID;
    pub fn igGetIDWithSeed_Int(n: ::core::ffi::c_int, seed: ImGuiID) -> ImGuiID;
    pub fn igItemSize_Vec2(size: ImVec2_c, text_baseline_y: f32);
    pub fn igItemSize_Rect(bb: ImRect_c, text_baseline_y: f32);
    pub fn igItemAdd(bb: ImRect_c, id: ImGuiID, nav_bb: *const ImRect, extra_flags: ImGuiItemFlags) -> bool;
    pub fn igItemHoverable(bb: ImRect_c, id: ImGuiID, item_flags: ImGuiItemFlags) -> bool;
    pub fn igIsWindowContentHoverable(window: *mut ImGuiWindow, flags: ImGuiHoveredFlags) -> bool;
    pub fn igIsClippedEx(bb: ImRect_c, id: ImGuiID) -> bool;
    pub fn igSetLastItemData(
        item_id: ImGuiID,
        item_flags: ImGuiItemFlags,
        status_flags: ImGuiItemStatusFlags,
        item_rect: ImRect_c,
    );
    pub fn igCalcItemSize(size: ImVec2_c, default_w: f32, default_h: f32) -> ImVec2_c;
    pub fn igCalcWrapWidthForPos(pos: ImVec2_c, wrap_pos_x: f32) -> f32;
    pub fn igPushMultiItemsWidths(components: ::core::ffi::c_int, width_full: f32);
    pub fn igShrinkWidths(items: *mut ImGuiShrinkWidthItem, count: ::core::ffi::c_int, width_excess: f32, width_min: f32);
    pub fn igCalcClipRectVisibleItemsY(
        clip_rect: ImRect_c,
        pos: ImVec2_c,
        items_height: f32,
        out_visible_start: *mut ::core::ffi::c_int,
        out_visible_end: *mut ::core::ffi::c_int,
    );
    pub fn igGetStyleVarInfo(idx: ImGuiStyleVar) -> *const ImGuiStyleVarInfo;
    pub fn igBeginDisabledOverrideReenable();
    pub fn igEndDisabledOverrideReenable();
    pub fn igLogBegin(flags: ImGuiLogFlags, auto_open_depth: ::core::ffi::c_int);
    pub fn igLogToBuffer(auto_open_depth: ::core::ffi::c_int);
    pub fn igLogRenderedText(ref_pos: *const ImVec2_c, text: *const ::core::ffi::c_char, text_end: *const ::core::ffi::c_char);
    pub fn igLogSetNextTextDecoration(prefix: *const ::core::ffi::c_char, suffix: *const ::core::ffi::c_char);
    pub fn igBeginChildEx(
        name: *const ::core::ffi::c_char,
        id: ImGuiID,
        size_arg: ImVec2_c,
        child_flags: ImGuiChildFlags,
        window_flags: ImGuiWindowFlags,
    ) -> bool;
    pub fn igFindFrontMostVisibleChildWindow(window: *mut ImGuiWindow) -> *mut ImGuiWindow;
    pub fn igBeginPopupEx(id: ImGuiID, extra_window_flags: ImGuiWindowFlags) -> bool;
    pub fn igBeginPopupMenuEx(id: ImGuiID, label: *const ::core::ffi::c_char, extra_window_flags: ImGuiWindowFlags) -> bool;
    pub fn igOpenPopupEx(id: ImGuiID, popup_flags: ImGuiPopupFlags);
    pub fn igClosePopupToLevel(remaining: ::core::ffi::c_int, restore_focus_to_window_under_popup: bool);
    pub fn igClosePopupsOverWindow(ref_window: *mut ImGuiWindow, restore_focus_to_window_under_popup: bool);
    pub fn igClosePopupsExceptModals();
    pub fn igIsPopupOpen_ID(id: ImGuiID, popup_flags: ImGuiPopupFlags) -> bool;
    pub fn igGetPopupAllowedExtentRect(window: *mut ImGuiWindow) -> ImRect_c;
    pub fn igGetTopMostPopupModal() -> *mut ImGuiWindow;
    pub fn igGetTopMostAndVisiblePopupModal() -> *mut ImGuiWindow;
    pub fn igFindBlockingModal(window: *mut ImGuiWindow) -> *mut ImGuiWindow;
    pub fn igFindBestWindowPosForPopup(window: *mut ImGuiWindow) -> ImVec2_c;
    pub fn igFindBestWindowPosForPopupEx(
        ref_pos: ImVec2_c,
        size: ImVec2_c,
        last_dir: *mut ImGuiDir,
        r_outer: ImRect_c,
        r_avoid: ImRect_c,
        policy: ImGuiPopupPositionPolicy,
    ) -> ImVec2_c;
    pub fn igGetMouseButtonFromPopupFlags(flags: ImGuiPopupFlags) -> ImGuiMouseButton;
    pub fn igIsPopupOpenRequestForItem(flags: ImGuiPopupFlags, id: ImGuiID) -> bool;
    pub fn igIsPopupOpenRequestForWindow(flags: ImGuiPopupFlags) -> bool;
    pub fn igBeginTooltipEx(tooltip_flags: ImGuiTooltipFlags, extra_window_flags: ImGuiWindowFlags) -> bool;
    pub fn igBeginTooltipHidden() -> bool;
    pub fn igBeginViewportSideBar(
        name: *const ::core::ffi::c_char,
        viewport: *mut ImGuiViewport,
        dir: ImGuiDir,
        size: f32,
        window_flags: ImGuiWindowFlags,
    ) -> bool;
    pub fn igBeginMenuEx(label: *const ::core::ffi::c_char, icon: *const ::core::ffi::c_char, enabled: bool) -> bool;
    pub fn igMenuItemEx(
        label: *const ::core::ffi::c_char,
        icon: *const ::core::ffi::c_char,
        shortcut: *const ::core::ffi::c_char,
        selected: bool,
        enabled: bool,
    ) -> bool;
    pub fn igBeginComboPopup(popup_id: ImGuiID, bb: ImRect_c, flags: ImGuiComboFlags) -> bool;
    pub fn igBeginComboPreview() -> bool;
    pub fn igEndComboPreview();
    pub fn igNavInitWindow(window: *mut ImGuiWindow, force_reinit: bool);
    pub fn igNavInitRequestApplyResult();
    pub fn igNavMoveRequestButNoResultYet() -> bool;
    pub fn igNavMoveRequestSubmit(
        move_dir: ImGuiDir,
        clip_dir: ImGuiDir,
        move_flags: ImGuiNavMoveFlags,
        scroll_flags: ImGuiScrollFlags,
    );
    pub fn igNavMoveRequestForward(
        move_dir: ImGuiDir,
        clip_dir: ImGuiDir,
        move_flags: ImGuiNavMoveFlags,
        scroll_flags: ImGuiScrollFlags,
    );
    pub fn igNavMoveRequestResolveWithLastItem(result: *mut ImGuiNavItemData);
    pub fn igNavMoveRequestResolveWithPastTreeNode(result: *mut ImGuiNavItemData, tree_node_data: *const ImGuiTreeNodeStackData);
    pub fn igNavMoveRequestCancel();
    pub fn igNavMoveRequestApplyResult();
    pub fn igNavMoveRequestTryWrapping(window: *mut ImGuiWindow, move_flags: ImGuiNavMoveFlags);
    pub fn igNavHighlightActivated(id: ImGuiID);
    pub fn igNavClearPreferredPosForAxis(axis: ImGuiAxis);
    pub fn igSetNavCursorVisibleAfterMove();
    pub fn igNavUpdateCurrentWindowIsScrollPushableX();
    pub fn igSetNavWindow(window: *mut ImGuiWindow);
    pub fn igSetNavID(id: ImGuiID, nav_layer: ImGuiNavLayer, focus_scope_id: ImGuiID, rect_rel: ImRect_c);
    pub fn igSetNavFocusScope(focus_scope_id: ImGuiID);
    pub fn igFocusItem();
    pub fn igActivateItemByID(id: ImGuiID);
    pub fn igIsNamedKey(key: ImGuiKey) -> bool;
    pub fn igIsNamedKeyOrMod(key: ImGuiKey) -> bool;
    pub fn igIsLegacyKey(key: ImGuiKey) -> bool;
    pub fn igIsKeyboardKey(key: ImGuiKey) -> bool;
    pub fn igIsGamepadKey(key: ImGuiKey) -> bool;
    pub fn igIsMouseKey(key: ImGuiKey) -> bool;
    pub fn igIsAliasKey(key: ImGuiKey) -> bool;
    pub fn igIsLRModKey(key: ImGuiKey) -> bool;
    pub fn igFixupKeyChord(key_chord: ImGuiKeyChord) -> ImGuiKeyChord;
    pub fn igConvertSingleModFlagToKey(key: ImGuiKey) -> ImGuiKey;
    pub fn igGetKeyData_ContextPtr(ctx: *mut ImGuiContext, key: ImGuiKey) -> *mut ImGuiKeyData;
    pub fn igGetKeyData_Key(key: ImGuiKey) -> *mut ImGuiKeyData;
    pub fn igGetKeyChordName(key_chord: ImGuiKeyChord) -> *const ::core::ffi::c_char;
    pub fn igMouseButtonToKey(button: ImGuiMouseButton) -> ImGuiKey;
    pub fn igIsMouseDragPastThreshold(button: ImGuiMouseButton, lock_threshold: f32) -> bool;
    pub fn igGetKeyMagnitude2d(key_left: ImGuiKey, key_right: ImGuiKey, key_up: ImGuiKey, key_down: ImGuiKey) -> ImVec2_c;
    pub fn igGetNavTweakPressedAmount(axis: ImGuiAxis) -> f32;
    pub fn igCalcTypematicRepeatAmount(t0: f32, t1: f32, repeat_delay: f32, repeat_rate: f32) -> ::core::ffi::c_int;
    pub fn igGetTypematicRepeatRate(flags: ImGuiInputFlags, repeat_delay: *mut f32, repeat_rate: *mut f32);
    pub fn igTeleportMousePos(pos: ImVec2_c);
    pub fn igSetActiveIdUsingAllKeyboardKeys();
    pub fn igIsActiveIdUsingNavDir(dir: ImGuiDir) -> bool;
    pub fn igGetKeyOwner(key: ImGuiKey) -> ImGuiID;
    pub fn igSetKeyOwner(key: ImGuiKey, owner_id: ImGuiID, flags: ImGuiInputFlags);
    pub fn igSetKeyOwnersForKeyChord(key: ImGuiKeyChord, owner_id: ImGuiID, flags: ImGuiInputFlags);
    pub fn igSetItemKeyOwner_InputFlags(key: ImGuiKey, flags: ImGuiInputFlags) -> bool;
    pub fn igTestKeyOwner(key: ImGuiKey, owner_id: ImGuiID) -> bool;
    pub fn igGetKeyOwnerData(ctx: *mut ImGuiContext, key: ImGuiKey) -> *mut ImGuiKeyOwnerData;
    pub fn igIsKeyDown_ID(key: ImGuiKey, owner_id: ImGuiID) -> bool;
    pub fn igIsKeyPressed_InputFlags(key: ImGuiKey, flags: ImGuiInputFlags, owner_id: ImGuiID) -> bool;
    pub fn igIsKeyReleased_ID(key: ImGuiKey, owner_id: ImGuiID) -> bool;
    pub fn igIsKeyChordPressed_InputFlags(key_chord: ImGuiKeyChord, flags: ImGuiInputFlags, owner_id: ImGuiID) -> bool;
    pub fn igIsMouseDown_ID(button: ImGuiMouseButton, owner_id: ImGuiID) -> bool;
    pub fn igIsMouseClicked_InputFlags(button: ImGuiMouseButton, flags: ImGuiInputFlags, owner_id: ImGuiID) -> bool;
    pub fn igIsMouseReleased_ID(button: ImGuiMouseButton, owner_id: ImGuiID) -> bool;
    pub fn igIsMouseDoubleClicked_ID(button: ImGuiMouseButton, owner_id: ImGuiID) -> bool;
    pub fn igShortcut_ID(key_chord: ImGuiKeyChord, flags: ImGuiInputFlags, owner_id: ImGuiID) -> bool;
    pub fn igSetShortcutRouting(key_chord: ImGuiKeyChord, flags: ImGuiInputFlags, owner_id: ImGuiID) -> bool;
    pub fn igTestShortcutRouting(key_chord: ImGuiKeyChord, owner_id: ImGuiID) -> bool;
    pub fn igGetShortcutRoutingData(key_chord: ImGuiKeyChord) -> *mut ImGuiKeyRoutingData;
    pub fn igPushFocusScope(id: ImGuiID);
    pub fn igPopFocusScope();
    pub fn igIsInNavFocusRoute(focus_scope_id: ImGuiID) -> bool;
    pub fn igGetCurrentFocusScope() -> ImGuiID;
    pub fn igIsDragDropActive() -> bool;
    pub fn igBeginDragDropTargetCustom(bb: ImRect_c, id: ImGuiID) -> bool;
    pub fn igBeginDragDropTargetViewport(viewport: *mut ImGuiViewport, p_bb: *const ImRect) -> bool;
    pub fn igClearDragDrop();
    pub fn igIsDragDropPayloadBeingAccepted() -> bool;
    pub fn igRenderDragDropTargetRectForItem(bb: ImRect_c);
    pub fn igRenderDragDropTargetRectEx(draw_list: *mut ImDrawList, bb: ImRect_c, rounding: f32);
    pub fn igGetTypingSelectRequest(flags: ImGuiTypingSelectFlags) -> *mut ImGuiTypingSelectRequest;
    pub fn igTypingSelectFindMatch(
        req: *mut ImGuiTypingSelectRequest,
        items_count: ::core::ffi::c_int,
        get_item_name_func: ::core::option::Option<
            unsafe extern "C" fn(arg1: *mut ::core::ffi::c_void, arg2: ::core::ffi::c_int) -> *const ::core::ffi::c_char,
        >,
        user_data: *mut ::core::ffi::c_void,
        nav_item_idx: ::core::ffi::c_int,
    ) -> ::core::ffi::c_int;
    pub fn igTypingSelectFindNextSingleCharMatch(
        req: *mut ImGuiTypingSelectRequest,
        items_count: ::core::ffi::c_int,
        get_item_name_func: ::core::option::Option<
            unsafe extern "C" fn(arg1: *mut ::core::ffi::c_void, arg2: ::core::ffi::c_int) -> *const ::core::ffi::c_char,
        >,
        user_data: *mut ::core::ffi::c_void,
        nav_item_idx: ::core::ffi::c_int,
    ) -> ::core::ffi::c_int;
    pub fn igTypingSelectFindBestLeadingMatch(
        req: *mut ImGuiTypingSelectRequest,
        items_count: ::core::ffi::c_int,
        get_item_name_func: ::core::option::Option<
            unsafe extern "C" fn(arg1: *mut ::core::ffi::c_void, arg2: ::core::ffi::c_int) -> *const ::core::ffi::c_char,
        >,
        user_data: *mut ::core::ffi::c_void,
    ) -> ::core::ffi::c_int;
    pub fn igBeginBoxSelect(
        scope_rect: ImRect_c,
        window: *mut ImGuiWindow,
        box_select_id: ImGuiID,
        ms_flags: ImGuiMultiSelectFlags,
    ) -> bool;
    pub fn igEndBoxSelect(scope_rect: ImRect_c, ms_flags: ImGuiMultiSelectFlags);
    pub fn igMultiSelectItemHeader(id: ImGuiID, p_selected: *mut bool, p_button_flags: *mut ImGuiButtonFlags);
    pub fn igMultiSelectItemFooter(id: ImGuiID, p_selected: *mut bool, p_pressed: *mut bool);
    pub fn igMultiSelectAddSetAll(ms: *mut ImGuiMultiSelectTempData, selected: bool);
    pub fn igMultiSelectAddSetRange(
        ms: *mut ImGuiMultiSelectTempData,
        selected: bool,
        range_dir: ::core::ffi::c_int,
        first_item: ImGuiSelectionUserData,
        last_item: ImGuiSelectionUserData,
    );
    pub fn igGetBoxSelectState(id: ImGuiID) -> *mut ImGuiBoxSelectState;
    pub fn igGetMultiSelectState(id: ImGuiID) -> *mut ImGuiMultiSelectState;
    pub fn igSetWindowClipRectBeforeSetChannel(window: *mut ImGuiWindow, clip_rect: ImRect_c);
    pub fn igBeginColumns(str_id: *const ::core::ffi::c_char, count: ::core::ffi::c_int, flags: ImGuiOldColumnFlags);
    pub fn igEndColumns();
    pub fn igPushColumnClipRect(column_index: ::core::ffi::c_int);
    pub fn igPushColumnsBackground();
    pub fn igPopColumnsBackground();
    pub fn igGetColumnsID(str_id: *const ::core::ffi::c_char, count: ::core::ffi::c_int) -> ImGuiID;
    pub fn igFindOrCreateColumns(window: *mut ImGuiWindow, id: ImGuiID) -> *mut ImGuiOldColumns;
    pub fn igGetColumnOffsetFromNorm(columns: *const ImGuiOldColumns, offset_norm: f32) -> f32;
    pub fn igGetColumnNormFromOffset(columns: *const ImGuiOldColumns, offset: f32) -> f32;
    pub fn igTableOpenContextMenu(column_n: ::core::ffi::c_int);
    pub fn igTableSetColumnWidth(column_n: ::core::ffi::c_int, width: f32);
    pub fn igTableSetColumnSortDirection(
        column_n: ::core::ffi::c_int,
        sort_direction: ImGuiSortDirection,
        append_to_sort_specs: bool,
    );
    pub fn igTableGetHoveredRow() -> ::core::ffi::c_int;
    pub fn igTableGetHeaderRowHeight() -> f32;
    pub fn igTableGetHeaderAngledMaxLabelWidth() -> f32;
    pub fn igTablePushBackgroundChannel();
    pub fn igTablePopBackgroundChannel();
    pub fn igTablePushColumnChannel(column_n: ::core::ffi::c_int);
    pub fn igTablePopColumnChannel();
    pub fn igTableAngledHeadersRowEx(
        row_id: ImGuiID,
        angle: f32,
        max_label_width: f32,
        data: *const ImGuiTableHeaderData,
        data_count: ::core::ffi::c_int,
    );
    pub fn igGetCurrentTable() -> *mut ImGuiTable;
    pub fn igTableFindByID(id: ImGuiID) -> *mut ImGuiTable;
    pub fn igBeginTableEx(
        name: *const ::core::ffi::c_char,
        id: ImGuiID,
        columns_count: ::core::ffi::c_int,
        flags: ImGuiTableFlags,
        outer_size: ImVec2_c,
        inner_width: f32,
    ) -> bool;
    pub fn igTableBeginInitMemory(table: *mut ImGuiTable, columns_count: ::core::ffi::c_int);
    pub fn igTableBeginApplyRequests(table: *mut ImGuiTable);
    pub fn igTableSetupDrawChannels(table: *mut ImGuiTable);
    pub fn igTableUpdateLayout(table: *mut ImGuiTable);
    pub fn igTableUpdateBorders(table: *mut ImGuiTable);
    pub fn igTableUpdateColumnsWeightFromWidth(table: *mut ImGuiTable);
    pub fn igTableApplyExternalUnclipRect(table: *mut ImGuiTable, rect: *mut ImRect);
    pub fn igTableDrawBorders(table: *mut ImGuiTable);
    pub fn igTableDrawDefaultContextMenu(table: *mut ImGuiTable, flags_for_section_to_display: ImGuiTableFlags);
    pub fn igTableBeginContextMenuPopup(table: *mut ImGuiTable) -> bool;
    pub fn igTableMergeDrawChannels(table: *mut ImGuiTable);
    pub fn igTableGetInstanceData(table: *mut ImGuiTable, instance_no: ::core::ffi::c_int) -> *mut ImGuiTableInstanceData;
    pub fn igTableGetInstanceID(table: *mut ImGuiTable, instance_no: ::core::ffi::c_int) -> ImGuiID;
    pub fn igTableFixDisplayOrder(table: *mut ImGuiTable);
    pub fn igTableSortSpecsSanitize(table: *mut ImGuiTable);
    pub fn igTableSortSpecsBuild(table: *mut ImGuiTable);
    pub fn igTableGetColumnNextSortDirection(column: *mut ImGuiTableColumn) -> ImGuiSortDirection;
    pub fn igTableFixColumnSortDirection(table: *mut ImGuiTable, column: *mut ImGuiTableColumn);
    pub fn igTableGetColumnWidthAuto(table: *mut ImGuiTable, column: *mut ImGuiTableColumn) -> f32;
    pub fn igTableBeginRow(table: *mut ImGuiTable);
    pub fn igTableEndRow(table: *mut ImGuiTable);
    pub fn igTableBeginCell(table: *mut ImGuiTable, column_n: ::core::ffi::c_int);
    pub fn igTableEndCell(table: *mut ImGuiTable);
    pub fn igTableGetCellBgRect(table: *const ImGuiTable, column_n: ::core::ffi::c_int) -> ImRect_c;
    pub fn igTableGetColumnName_TablePtr(table: *const ImGuiTable, column_n: ::core::ffi::c_int) -> *const ::core::ffi::c_char;
    pub fn igTableGetColumnResizeID(
        table: *mut ImGuiTable,
        column_n: ::core::ffi::c_int,
        instance_no: ::core::ffi::c_int,
    ) -> ImGuiID;
    pub fn igTableCalcMaxColumnWidth(table: *const ImGuiTable, column_n: ::core::ffi::c_int) -> f32;
    pub fn igTableSetColumnWidthAutoSingle(table: *mut ImGuiTable, column_n: ::core::ffi::c_int);
    pub fn igTableSetColumnWidthAutoAll(table: *mut ImGuiTable);
    pub fn igTableSetColumnDisplayOrder(table: *mut ImGuiTable, column_n: ::core::ffi::c_int, dst_order: ::core::ffi::c_int);
    pub fn igTableQueueSetColumnDisplayOrder(table: *mut ImGuiTable, column_n: ::core::ffi::c_int, dst_order: ::core::ffi::c_int);
    pub fn igTableRemove(table: *mut ImGuiTable);
    pub fn igTableGcCompactTransientBuffers_TablePtr(table: *mut ImGuiTable);
    pub fn igTableGcCompactTransientBuffers_TableTempDataPtr(table: *mut ImGuiTableTempData);
    pub fn igTableGcCompactSettings();
    pub fn igTableLoadSettings(table: *mut ImGuiTable);
    pub fn igTableSaveSettings(table: *mut ImGuiTable);
    pub fn igTableResetSettings(table: *mut ImGuiTable);
    pub fn igTableGetBoundSettings(table: *mut ImGuiTable) -> *mut ImGuiTableSettings;
    pub fn igTableSettingsAddSettingsHandler();
    pub fn igTableSettingsCreate(id: ImGuiID, columns_count: ::core::ffi::c_int) -> *mut ImGuiTableSettings;
    pub fn igTableSettingsFindByID(id: ImGuiID) -> *mut ImGuiTableSettings;
    pub fn igGetCurrentTabBar() -> *mut ImGuiTabBar;
    pub fn igTabBarFindByID(id: ImGuiID) -> *mut ImGuiTabBar;
    pub fn igTabBarRemove(tab_bar: *mut ImGuiTabBar);
    pub fn igBeginTabBarEx(tab_bar: *mut ImGuiTabBar, bb: ImRect_c, flags: ImGuiTabBarFlags) -> bool;
    pub fn igTabBarFindTabByID(tab_bar: *mut ImGuiTabBar, tab_id: ImGuiID) -> *mut ImGuiTabItem;
    pub fn igTabBarFindTabByOrder(tab_bar: *mut ImGuiTabBar, order: ::core::ffi::c_int) -> *mut ImGuiTabItem;
    pub fn igTabBarGetCurrentTab(tab_bar: *mut ImGuiTabBar) -> *mut ImGuiTabItem;
    pub fn igTabBarGetTabOrder(tab_bar: *mut ImGuiTabBar, tab: *mut ImGuiTabItem) -> ::core::ffi::c_int;
    pub fn igTabBarGetTabName(tab_bar: *mut ImGuiTabBar, tab: *mut ImGuiTabItem) -> *const ::core::ffi::c_char;
    pub fn igTabBarRemoveTab(tab_bar: *mut ImGuiTabBar, tab_id: ImGuiID);
    pub fn igTabBarCloseTab(tab_bar: *mut ImGuiTabBar, tab: *mut ImGuiTabItem);
    pub fn igTabBarQueueFocus_TabItemPtr(tab_bar: *mut ImGuiTabBar, tab: *mut ImGuiTabItem);
    pub fn igTabBarQueueFocus_Str(tab_bar: *mut ImGuiTabBar, tab_name: *const ::core::ffi::c_char);
    pub fn igTabBarQueueReorder(tab_bar: *mut ImGuiTabBar, tab: *mut ImGuiTabItem, offset: ::core::ffi::c_int);
    pub fn igTabBarQueueReorderFromMousePos(tab_bar: *mut ImGuiTabBar, tab: *mut ImGuiTabItem, mouse_pos: ImVec2_c);
    pub fn igTabBarProcessReorder(tab_bar: *mut ImGuiTabBar) -> bool;
    pub fn igTabItemEx(
        tab_bar: *mut ImGuiTabBar,
        label: *const ::core::ffi::c_char,
        p_open: *mut bool,
        flags: ImGuiTabItemFlags,
        docked_window: *mut ImGuiWindow,
    ) -> bool;
    pub fn igTabItemSpacing(str_id: *const ::core::ffi::c_char, flags: ImGuiTabItemFlags, width: f32);
    pub fn igTabItemCalcSize_Str(label: *const ::core::ffi::c_char, has_close_button_or_unsaved_marker: bool) -> ImVec2_c;
    pub fn igTabItemCalcSize_WindowPtr(window: *mut ImGuiWindow) -> ImVec2_c;
    pub fn igTabItemBackground(draw_list: *mut ImDrawList, bb: ImRect_c, flags: ImGuiTabItemFlags, col: ImU32);
    pub fn igTabItemLabelAndCloseButton(
        draw_list: *mut ImDrawList,
        bb: ImRect_c,
        flags: ImGuiTabItemFlags,
        frame_padding: ImVec2_c,
        label: *const ::core::ffi::c_char,
        tab_id: ImGuiID,
        close_button_id: ImGuiID,
        is_contents_visible: bool,
        out_just_closed: *mut bool,
        out_text_clipped: *mut bool,
    );
    pub fn igRenderText(
        pos: ImVec2_c,
        text: *const ::core::ffi::c_char,
        text_end: *const ::core::ffi::c_char,
        hide_text_after_hash: bool,
    );
    pub fn igRenderTextWrapped(
        pos: ImVec2_c,
        text: *const ::core::ffi::c_char,
        text_end: *const ::core::ffi::c_char,
        wrap_width: f32,
    );
    pub fn igRenderTextClipped(
        pos_min: ImVec2_c,
        pos_max: ImVec2_c,
        text: *const ::core::ffi::c_char,
        text_end: *const ::core::ffi::c_char,
        text_size_if_known: *const ImVec2_c,
        align: ImVec2_c,
        clip_rect: *const ImRect,
    );
    pub fn igRenderTextClippedEx(
        draw_list: *mut ImDrawList,
        pos_min: ImVec2_c,
        pos_max: ImVec2_c,
        text: *const ::core::ffi::c_char,
        text_end: *const ::core::ffi::c_char,
        text_size_if_known: *const ImVec2_c,
        align: ImVec2_c,
        clip_rect: *const ImRect,
    );
    pub fn igRenderTextEllipsis(
        draw_list: *mut ImDrawList,
        pos_min: ImVec2_c,
        pos_max: ImVec2_c,
        ellipsis_max_x: f32,
        text: *const ::core::ffi::c_char,
        text_end: *const ::core::ffi::c_char,
        text_size_if_known: *const ImVec2_c,
    );
    pub fn igRenderFrame(p_min: ImVec2_c, p_max: ImVec2_c, fill_col: ImU32, borders: bool, rounding: f32);
    pub fn igRenderFrameBorder(p_min: ImVec2_c, p_max: ImVec2_c, rounding: f32);
    pub fn igRenderColorComponentMarker(bb: ImRect_c, col: ImU32, rounding: f32);
    pub fn igRenderColorRectWithAlphaCheckerboard(
        draw_list: *mut ImDrawList,
        p_min: ImVec2_c,
        p_max: ImVec2_c,
        fill_col: ImU32,
        grid_step: f32,
        grid_off: ImVec2_c,
        rounding: f32,
        flags: ImDrawFlags,
    );
    pub fn igRenderNavCursor(bb: ImRect_c, id: ImGuiID, flags: ImGuiNavRenderCursorFlags);
    pub fn igFindRenderedTextEnd(
        text: *const ::core::ffi::c_char,
        text_end: *const ::core::ffi::c_char,
    ) -> *const ::core::ffi::c_char;
    pub fn igRenderMouseCursor(
        pos: ImVec2_c,
        scale: f32,
        mouse_cursor: ImGuiMouseCursor,
        col_fill: ImU32,
        col_border: ImU32,
        col_shadow: ImU32,
    );
    pub fn igRenderArrow(draw_list: *mut ImDrawList, pos: ImVec2_c, col: ImU32, dir: ImGuiDir, scale: f32);
    pub fn igRenderBullet(draw_list: *mut ImDrawList, pos: ImVec2_c, col: ImU32);
    pub fn igRenderCheckMark(draw_list: *mut ImDrawList, pos: ImVec2_c, col: ImU32, sz: f32);
    pub fn igRenderArrowPointingAt(draw_list: *mut ImDrawList, pos: ImVec2_c, half_sz: ImVec2_c, direction: ImGuiDir, col: ImU32);
    pub fn igRenderRectFilledInRangeH(
        draw_list: *mut ImDrawList,
        rect: ImRect_c,
        col: ImU32,
        fill_x0: f32,
        fill_x1: f32,
        rounding: f32,
    );
    pub fn igRenderRectFilledWithHole(draw_list: *mut ImDrawList, outer: ImRect_c, inner: ImRect_c, col: ImU32, rounding: f32);
    pub fn igCalcRoundingFlagsForRectInRect(r_in: ImRect_c, r_outer: ImRect_c, threshold: f32) -> ImDrawFlags;
    pub fn igTextEx(text: *const ::core::ffi::c_char, text_end: *const ::core::ffi::c_char, flags: ImGuiTextFlags);
    pub fn igTextAligned(align_x: f32, size_x: f32, fmt: *const ::core::ffi::c_char, ...);
    pub fn igTextAlignedV(align_x: f32, size_x: f32, fmt: *const ::core::ffi::c_char, args: va_list);
    pub fn igButtonEx(label: *const ::core::ffi::c_char, size_arg: ImVec2_c, flags: ImGuiButtonFlags) -> bool;
    pub fn igArrowButtonEx(
        str_id: *const ::core::ffi::c_char,
        dir: ImGuiDir,
        size_arg: ImVec2_c,
        flags: ImGuiButtonFlags,
    ) -> bool;
    pub fn igImageButtonEx(
        id: ImGuiID,
        tex_ref: ImTextureRef_c,
        image_size: ImVec2_c,
        uv0: ImVec2_c,
        uv1: ImVec2_c,
        bg_col: ImVec4_c,
        tint_col: ImVec4_c,
        flags: ImGuiButtonFlags,
    ) -> bool;
    pub fn igSeparatorEx(flags: ImGuiSeparatorFlags, thickness: f32);
    pub fn igSeparatorTextEx(
        id: ImGuiID,
        label: *const ::core::ffi::c_char,
        label_end: *const ::core::ffi::c_char,
        extra_width: f32,
    );
    pub fn igCheckboxFlags_S64Ptr(label: *const ::core::ffi::c_char, flags: *mut ImS64, flags_value: ImS64) -> bool;
    pub fn igCheckboxFlags_U64Ptr(label: *const ::core::ffi::c_char, flags: *mut ImU64, flags_value: ImU64) -> bool;
    pub fn igCloseButton(id: ImGuiID, pos: ImVec2_c) -> bool;
    pub fn igCollapseButton(id: ImGuiID, pos: ImVec2_c) -> bool;
    pub fn igScrollbar(axis: ImGuiAxis);
    pub fn igScrollbarEx(
        bb: ImRect_c,
        id: ImGuiID,
        axis: ImGuiAxis,
        p_scroll_v: *mut ImS64,
        avail_v: ImS64,
        contents_v: ImS64,
        draw_rounding_flags: ImDrawFlags,
    ) -> bool;
    pub fn igGetWindowScrollbarRect(window: *mut ImGuiWindow, axis: ImGuiAxis) -> ImRect_c;
    pub fn igGetWindowScrollbarID(window: *mut ImGuiWindow, axis: ImGuiAxis) -> ImGuiID;
    pub fn igGetWindowResizeCornerID(window: *mut ImGuiWindow, n: ::core::ffi::c_int) -> ImGuiID;
    pub fn igGetWindowResizeBorderID(window: *mut ImGuiWindow, dir: ImGuiDir) -> ImGuiID;
    pub fn igExtendHitBoxWhenNearViewportEdge(window: *mut ImGuiWindow, bb: *mut ImRect, threshold: f32, axis: ImGuiAxis);
    pub fn igButtonBehavior(
        bb: ImRect_c,
        id: ImGuiID,
        out_hovered: *mut bool,
        out_held: *mut bool,
        flags: ImGuiButtonFlags,
    ) -> bool;
    pub fn igDragBehavior(
        id: ImGuiID,
        data_type: ImGuiDataType,
        p_v: *mut ::core::ffi::c_void,
        v_speed: f32,
        p_min: *const ::core::ffi::c_void,
        p_max: *const ::core::ffi::c_void,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
    ) -> bool;
    pub fn igSliderBehavior(
        bb: ImRect_c,
        id: ImGuiID,
        data_type: ImGuiDataType,
        p_v: *mut ::core::ffi::c_void,
        p_min: *const ::core::ffi::c_void,
        p_max: *const ::core::ffi::c_void,
        format: *const ::core::ffi::c_char,
        flags: ImGuiSliderFlags,
        out_grab_bb: *mut ImRect,
    ) -> bool;
    pub fn igSplitterBehavior(
        bb: ImRect_c,
        id: ImGuiID,
        axis: ImGuiAxis,
        size1: *mut f32,
        size2: *mut f32,
        min_size1: f32,
        min_size2: f32,
        hover_extend: f32,
        hover_visibility_delay: f32,
        bg_col: ImU32,
    ) -> bool;
    pub fn igTreeNodeBehavior(
        id: ImGuiID,
        flags: ImGuiTreeNodeFlags,
        label: *const ::core::ffi::c_char,
        label_end: *const ::core::ffi::c_char,
    ) -> bool;
    pub fn igTreeNodeDrawLineToChildNode(target_pos: ImVec2_c);
    pub fn igTreeNodeDrawLineToTreePop(data: *const ImGuiTreeNodeStackData);
    pub fn igTreePushOverrideID(id: ImGuiID);
    pub fn igTreeNodeSetOpen(storage_id: ImGuiID, open: bool);
    pub fn igTreeNodeUpdateNextOpen(storage_id: ImGuiID, flags: ImGuiTreeNodeFlags) -> bool;
    pub fn igDataTypeGetInfo(data_type: ImGuiDataType) -> *const ImGuiDataTypeInfo;
    pub fn igDataTypeFormatString(
        buf: *mut ::core::ffi::c_char,
        buf_size: ::core::ffi::c_int,
        data_type: ImGuiDataType,
        p_data: *const ::core::ffi::c_void,
        format: *const ::core::ffi::c_char,
    ) -> ::core::ffi::c_int;
    pub fn igDataTypeApplyOp(
        data_type: ImGuiDataType,
        op: ::core::ffi::c_int,
        output: *mut ::core::ffi::c_void,
        arg_1: *const ::core::ffi::c_void,
        arg_2: *const ::core::ffi::c_void,
    );
    pub fn igDataTypeApplyFromText(
        buf: *const ::core::ffi::c_char,
        data_type: ImGuiDataType,
        p_data: *mut ::core::ffi::c_void,
        format: *const ::core::ffi::c_char,
        p_data_when_empty: *mut ::core::ffi::c_void,
    ) -> bool;
    pub fn igDataTypeCompare(
        data_type: ImGuiDataType,
        arg_1: *const ::core::ffi::c_void,
        arg_2: *const ::core::ffi::c_void,
    ) -> ::core::ffi::c_int;
    pub fn igDataTypeClamp(
        data_type: ImGuiDataType,
        p_data: *mut ::core::ffi::c_void,
        p_min: *const ::core::ffi::c_void,
        p_max: *const ::core::ffi::c_void,
    ) -> bool;
    pub fn igDataTypeIsZero(data_type: ImGuiDataType, p_data: *const ::core::ffi::c_void) -> bool;
    pub fn igInputTextEx(
        label: *const ::core::ffi::c_char,
        hint: *const ::core::ffi::c_char,
        buf: *mut ::core::ffi::c_char,
        buf_size: ::core::ffi::c_int,
        size_arg: ImVec2_c,
        flags: ImGuiInputTextFlags,
        callback: ImGuiInputTextCallback,
        user_data: *mut ::core::ffi::c_void,
    ) -> bool;
    pub fn igInputTextDeactivateHook(id: ImGuiID);
    pub fn igTempInputText(
        bb: ImRect_c,
        id: ImGuiID,
        label: *const ::core::ffi::c_char,
        buf: *mut ::core::ffi::c_char,
        buf_size: usize,
        flags: ImGuiInputTextFlags,
        callback: ImGuiInputTextCallback,
        user_data: *mut ::core::ffi::c_void,
    ) -> bool;
    pub fn igTempInputScalar(
        bb: ImRect_c,
        id: ImGuiID,
        label: *const ::core::ffi::c_char,
        data_type: ImGuiDataType,
        p_data: *mut ::core::ffi::c_void,
        format: *const ::core::ffi::c_char,
        p_clamp_min: *const ::core::ffi::c_void,
        p_clamp_max: *const ::core::ffi::c_void,
    ) -> bool;
    pub fn igTempInputIsActive(id: ImGuiID) -> bool;
    pub fn igGetInputTextState(id: ImGuiID) -> *mut ImGuiInputTextState;
    pub fn igSetNextItemRefVal(data_type: ImGuiDataType, p_data: *mut ::core::ffi::c_void);
    pub fn igIsItemActiveAsInputText() -> bool;
    pub fn igColorTooltip(text: *const ::core::ffi::c_char, col: *const f32, flags: ImGuiColorEditFlags);
    pub fn igColorEditOptionsPopup(col: *const f32, flags: ImGuiColorEditFlags);
    pub fn igColorPickerOptionsPopup(ref_col: *const f32, flags: ImGuiColorEditFlags);
    pub fn igSetNextItemColorMarker(col: ImU32);
    pub fn igPlotEx(
        plot_type: ImGuiPlotType,
        label: *const ::core::ffi::c_char,
        values_getter: ::core::option::Option<
            unsafe extern "C" fn(data: *mut ::core::ffi::c_void, idx: ::core::ffi::c_int) -> f32,
        >,
        data: *mut ::core::ffi::c_void,
        values_count: ::core::ffi::c_int,
        values_offset: ::core::ffi::c_int,
        overlay_text: *const ::core::ffi::c_char,
        scale_min: f32,
        scale_max: f32,
        size_arg: ImVec2_c,
    ) -> ::core::ffi::c_int;
    pub fn igShadeVertsLinearColorGradientKeepAlpha(
        draw_list: *mut ImDrawList,
        vert_start_idx: ::core::ffi::c_int,
        vert_end_idx: ::core::ffi::c_int,
        gradient_p0: ImVec2_c,
        gradient_p1: ImVec2_c,
        col0: ImU32,
        col1: ImU32,
    );
    pub fn igShadeVertsLinearUV(
        draw_list: *mut ImDrawList,
        vert_start_idx: ::core::ffi::c_int,
        vert_end_idx: ::core::ffi::c_int,
        a: ImVec2_c,
        b: ImVec2_c,
        uv_a: ImVec2_c,
        uv_b: ImVec2_c,
        clamp: bool,
    );
    pub fn igShadeVertsTransformPos(
        draw_list: *mut ImDrawList,
        vert_start_idx: ::core::ffi::c_int,
        vert_end_idx: ::core::ffi::c_int,
        pivot_in: ImVec2_c,
        cos_a: f32,
        sin_a: f32,
        pivot_out: ImVec2_c,
    );
    pub fn igGcCompactTransientMiscBuffers();
    pub fn igGcCompactTransientWindowBuffers(window: *mut ImGuiWindow);
    pub fn igGcAwakeTransientWindowBuffers(window: *mut ImGuiWindow);
    pub fn igErrorLog(msg: *const ::core::ffi::c_char) -> bool;
    pub fn igErrorRecoveryStoreState(state_out: *mut ImGuiErrorRecoveryState);
    pub fn igErrorRecoveryTryToRecoverState(state_in: *const ImGuiErrorRecoveryState);
    pub fn igErrorRecoveryTryToRecoverWindowState(state_in: *const ImGuiErrorRecoveryState);
    pub fn igErrorCheckUsingSetCursorPosToExtendParentBoundaries();
    pub fn igErrorCheckEndFrameFinalizeErrorTooltip();
    pub fn igBeginErrorTooltip() -> bool;
    pub fn igEndErrorTooltip();
    pub fn igDemoMarker(file: *const ::core::ffi::c_char, line: ::core::ffi::c_int, section: *const ::core::ffi::c_char);
    pub fn igDebugAllocHook(
        info: *mut ImGuiDebugAllocInfo,
        frame_count: ::core::ffi::c_int,
        ptr: *mut ::core::ffi::c_void,
        size: usize,
    );
    pub fn igDebugDrawCursorPos(col: ImU32);
    pub fn igDebugDrawLineExtents(col: ImU32);
    pub fn igDebugDrawItemRect(col: ImU32);
    pub fn igDebugTextUnformattedWithLocateItem(line_begin: *const ::core::ffi::c_char, line_end: *const ::core::ffi::c_char);
    pub fn igDebugLocateItem(target_id: ImGuiID);
    pub fn igDebugLocateItemOnHover(target_id: ImGuiID);
    pub fn igDebugLocateItemResolveWithLastItem();
    pub fn igDebugBreakClearData();
    pub fn igDebugBreakButton(label: *const ::core::ffi::c_char, description_of_location: *const ::core::ffi::c_char) -> bool;
    pub fn igDebugBreakButtonTooltip(keyboard_only: bool, description_of_location: *const ::core::ffi::c_char);
    pub fn igShowFontAtlas(atlas: *mut ImFontAtlas);
    pub fn igDebugTextureIDToU64(tex_id: ImTextureID) -> ImU64;
    pub fn igDebugHookIdInfo(
        id: ImGuiID,
        data_type: ImGuiDataType,
        data_id: *const ::core::ffi::c_void,
        data_id_end: *const ::core::ffi::c_void,
    );
    pub fn igDebugNodeColumns(columns: *mut ImGuiOldColumns);
    pub fn igDebugNodeDrawList(
        window: *mut ImGuiWindow,
        viewport: *mut ImGuiViewportP,
        draw_list: *const ImDrawList,
        label: *const ::core::ffi::c_char,
    );
    pub fn igDebugNodeDrawCmdShowMeshAndBoundingBox(
        out_draw_list: *mut ImDrawList,
        draw_list: *const ImDrawList,
        draw_cmd: *const ImDrawCmd,
        show_mesh: bool,
        show_aabb: bool,
    );
    pub fn igDebugNodeFont(font: *mut ImFont);
    pub fn igDebugNodeFontGlyphsForSrcMask(font: *mut ImFont, baked: *mut ImFontBaked, src_mask: ::core::ffi::c_int);
    pub fn igDebugNodeFontGlyph(font: *mut ImFont, glyph: *const ImFontGlyph);
    pub fn igDebugNodeTexture(tex: *mut ImTextureData, int_id: ::core::ffi::c_int, highlight_rect: *const ImFontAtlasRect);
    pub fn igDebugNodeStorage(storage: *mut ImGuiStorage, label: *const ::core::ffi::c_char);
    pub fn igDebugNodeTabBar(tab_bar: *mut ImGuiTabBar, label: *const ::core::ffi::c_char);
    pub fn igDebugNodeTable(table: *mut ImGuiTable);
    pub fn igDebugNodeTableSettings(settings: *mut ImGuiTableSettings);
    pub fn igDebugNodeInputTextState(state: *mut ImGuiInputTextState);
    pub fn igDebugNodeTypingSelectState(state: *mut ImGuiTypingSelectState);
    pub fn igDebugNodeMultiSelectState(state: *mut ImGuiMultiSelectState);
    pub fn igDebugNodeWindow(window: *mut ImGuiWindow, label: *const ::core::ffi::c_char);
    pub fn igDebugNodeWindowSettings(settings: *mut ImGuiWindowSettings);
    pub fn igDebugNodeWindowsList(windows: *mut ImVector_ImGuiWindowPtr, label: *const ::core::ffi::c_char);
    pub fn igDebugNodeWindowsListByBeginStackParent(
        windows: *mut *mut ImGuiWindow,
        windows_size: ::core::ffi::c_int,
        parent_in_begin_stack: *mut ImGuiWindow,
    );
    pub fn igDebugNodeViewport(viewport: *mut ImGuiViewportP);
    pub fn igDebugRenderKeyboardPreview(draw_list: *mut ImDrawList);
    pub fn igDebugRenderViewportThumbnail(draw_list: *mut ImDrawList, viewport: *mut ImGuiViewportP, bb: ImRect_c);
    pub fn ImFontLoader_ImFontLoader() -> *mut ImFontLoader;
    pub fn ImFontLoader_destroy(self_: *mut ImFontLoader);
    pub fn igImFontAtlasGetFontLoaderForStbTruetype() -> *const ImFontLoader;
    pub fn igImFontAtlasRectId_GetIndex(id: ImFontAtlasRectId) -> ::core::ffi::c_int;
    pub fn igImFontAtlasRectId_GetGeneration(id: ImFontAtlasRectId) -> ::core::ffi::c_uint;
    pub fn igImFontAtlasRectId_Make(index_idx: ::core::ffi::c_int, gen_idx: ::core::ffi::c_int) -> ImFontAtlasRectId;
    pub fn ImFontAtlasBuilder_ImFontAtlasBuilder() -> *mut ImFontAtlasBuilder;
    pub fn ImFontAtlasBuilder_destroy(self_: *mut ImFontAtlasBuilder);
    pub fn igImFontAtlasBuildInit(atlas: *mut ImFontAtlas);
    pub fn igImFontAtlasBuildDestroy(atlas: *mut ImFontAtlas);
    pub fn igImFontAtlasBuildMain(atlas: *mut ImFontAtlas);
    pub fn igImFontAtlasBuildSetupFontLoader(atlas: *mut ImFontAtlas, font_loader: *const ImFontLoader);
    pub fn igImFontAtlasBuildNotifySetFont(atlas: *mut ImFontAtlas, old_font: *mut ImFont, new_font: *mut ImFont);
    pub fn igImFontAtlasBuildUpdatePointers(atlas: *mut ImFontAtlas);
    pub fn igImFontAtlasBuildRenderBitmapFromString(
        atlas: *mut ImFontAtlas,
        x: ::core::ffi::c_int,
        y: ::core::ffi::c_int,
        w: ::core::ffi::c_int,
        h: ::core::ffi::c_int,
        in_str: *const ::core::ffi::c_char,
        in_marker_char: ::core::ffi::c_char,
    );
    pub fn igImFontAtlasBuildClear(atlas: *mut ImFontAtlas);
    pub fn igImFontAtlasTextureAdd(atlas: *mut ImFontAtlas, w: ::core::ffi::c_int, h: ::core::ffi::c_int) -> *mut ImTextureData;
    pub fn igImFontAtlasTextureMakeSpace(atlas: *mut ImFontAtlas);
    pub fn igImFontAtlasTextureRepack(atlas: *mut ImFontAtlas, w: ::core::ffi::c_int, h: ::core::ffi::c_int);
    pub fn igImFontAtlasTextureGrow(atlas: *mut ImFontAtlas, old_w: ::core::ffi::c_int, old_h: ::core::ffi::c_int);
    pub fn igImFontAtlasTextureCompact(atlas: *mut ImFontAtlas);
    pub fn igImFontAtlasTextureGetSizeEstimate(atlas: *mut ImFontAtlas) -> ImVec2i_c;
    pub fn igImFontAtlasBuildSetupFontSpecialGlyphs(atlas: *mut ImFontAtlas, font: *mut ImFont, src: *mut ImFontConfig);
    pub fn igImFontAtlasBuildLegacyPreloadAllGlyphRanges(atlas: *mut ImFontAtlas);
    pub fn igImFontAtlasBuildGetOversampleFactors(
        src: *mut ImFontConfig,
        baked: *mut ImFontBaked,
        out_oversample_h: *mut ::core::ffi::c_int,
        out_oversample_v: *mut ::core::ffi::c_int,
    );
    pub fn igImFontAtlasBuildDiscardBakes(atlas: *mut ImFontAtlas, unused_frames: ::core::ffi::c_int);
    pub fn igImFontAtlasFontSourceInit(atlas: *mut ImFontAtlas, src: *mut ImFontConfig) -> bool;
    pub fn igImFontAtlasFontSourceAddToFont(atlas: *mut ImFontAtlas, font: *mut ImFont, src: *mut ImFontConfig);
    pub fn igImFontAtlasFontDestroySourceData(atlas: *mut ImFontAtlas, src: *mut ImFontConfig);
    pub fn igImFontAtlasFontInitOutput(atlas: *mut ImFontAtlas, font: *mut ImFont) -> bool;
    pub fn igImFontAtlasFontDestroyOutput(atlas: *mut ImFontAtlas, font: *mut ImFont);
    pub fn igImFontAtlasFontRebuildOutput(atlas: *mut ImFontAtlas, font: *mut ImFont);
    pub fn igImFontAtlasFontDiscardBakes(atlas: *mut ImFontAtlas, font: *mut ImFont, unused_frames: ::core::ffi::c_int);
    pub fn igImFontAtlasBakedGetId(font_id: ImGuiID, baked_size: f32, rasterizer_density: f32) -> ImGuiID;
    pub fn igImFontAtlasBakedGetOrAdd(
        atlas: *mut ImFontAtlas,
        font: *mut ImFont,
        font_size: f32,
        font_rasterizer_density: f32,
    ) -> *mut ImFontBaked;
    pub fn igImFontAtlasBakedGetClosestMatch(
        atlas: *mut ImFontAtlas,
        font: *mut ImFont,
        font_size: f32,
        font_rasterizer_density: f32,
    ) -> *mut ImFontBaked;
    pub fn igImFontAtlasBakedAdd(
        atlas: *mut ImFontAtlas,
        font: *mut ImFont,
        font_size: f32,
        font_rasterizer_density: f32,
        baked_id: ImGuiID,
    ) -> *mut ImFontBaked;
    pub fn igImFontAtlasBakedDiscard(atlas: *mut ImFontAtlas, font: *mut ImFont, baked: *mut ImFontBaked);
    pub fn igImFontAtlasBakedAddFontGlyph(
        atlas: *mut ImFontAtlas,
        baked: *mut ImFontBaked,
        src: *mut ImFontConfig,
        in_glyph: *const ImFontGlyph,
    ) -> *mut ImFontGlyph;
    pub fn igImFontAtlasBakedAddFontGlyphAdvancedX(
        atlas: *mut ImFontAtlas,
        baked: *mut ImFontBaked,
        src: *mut ImFontConfig,
        codepoint: ImWchar,
        advance_x: f32,
    );
    pub fn igImFontAtlasBakedDiscardFontGlyph(
        atlas: *mut ImFontAtlas,
        font: *mut ImFont,
        baked: *mut ImFontBaked,
        glyph: *mut ImFontGlyph,
    );
    pub fn igImFontAtlasBakedSetFontGlyphBitmap(
        atlas: *mut ImFontAtlas,
        baked: *mut ImFontBaked,
        src: *mut ImFontConfig,
        glyph: *mut ImFontGlyph,
        r: *mut ImTextureRect,
        src_pixels: *const ::core::ffi::c_uchar,
        src_fmt: ImTextureFormat,
        src_pitch: ::core::ffi::c_int,
    );
    pub fn igImFontAtlasPackInit(atlas: *mut ImFontAtlas);
    pub fn igImFontAtlasPackAddRect(
        atlas: *mut ImFontAtlas,
        w: ::core::ffi::c_int,
        h: ::core::ffi::c_int,
        overwrite_entry: *mut ImFontAtlasRectEntry,
    ) -> ImFontAtlasRectId;
    pub fn igImFontAtlasPackGetRect(atlas: *mut ImFontAtlas, id: ImFontAtlasRectId) -> *mut ImTextureRect;
    pub fn igImFontAtlasPackGetRectSafe(atlas: *mut ImFontAtlas, id: ImFontAtlasRectId) -> *mut ImTextureRect;
    pub fn igImFontAtlasPackDiscardRect(atlas: *mut ImFontAtlas, id: ImFontAtlasRectId);
    pub fn igImFontAtlasUpdateNewFrame(atlas: *mut ImFontAtlas, frame_count: ::core::ffi::c_int, renderer_has_textures: bool);
    pub fn igImFontAtlasAddDrawListSharedData(atlas: *mut ImFontAtlas, data: *mut ImDrawListSharedData);
    pub fn igImFontAtlasRemoveDrawListSharedData(atlas: *mut ImFontAtlas, data: *mut ImDrawListSharedData);
    pub fn igImFontAtlasUpdateDrawListsTextures(atlas: *mut ImFontAtlas, old_tex: ImTextureRef_c, new_tex: ImTextureRef_c);
    pub fn igImFontAtlasUpdateDrawListsSharedData(atlas: *mut ImFontAtlas);
    pub fn igImFontAtlasTextureBlockConvert(
        src_pixels: *const ::core::ffi::c_uchar,
        src_fmt: ImTextureFormat,
        src_pitch: ::core::ffi::c_int,
        dst_pixels: *mut ::core::ffi::c_uchar,
        dst_fmt: ImTextureFormat,
        dst_pitch: ::core::ffi::c_int,
        w: ::core::ffi::c_int,
        h: ::core::ffi::c_int,
    );
    pub fn igImFontAtlasTextureBlockPostProcess(data: *mut ImFontAtlasPostProcessData);
    pub fn igImFontAtlasTextureBlockPostProcessMultiply(data: *mut ImFontAtlasPostProcessData, multiply_factor: f32);
    pub fn igImFontAtlasTextureBlockFill(
        dst_tex: *mut ImTextureData,
        dst_x: ::core::ffi::c_int,
        dst_y: ::core::ffi::c_int,
        w: ::core::ffi::c_int,
        h: ::core::ffi::c_int,
        col: ImU32,
    );
    pub fn igImFontAtlasTextureBlockCopy(
        src_tex: *mut ImTextureData,
        src_x: ::core::ffi::c_int,
        src_y: ::core::ffi::c_int,
        dst_tex: *mut ImTextureData,
        dst_x: ::core::ffi::c_int,
        dst_y: ::core::ffi::c_int,
        w: ::core::ffi::c_int,
        h: ::core::ffi::c_int,
    );
    pub fn igImFontAtlasTextureBlockQueueUpload(
        atlas: *mut ImFontAtlas,
        tex: *mut ImTextureData,
        x: ::core::ffi::c_int,
        y: ::core::ffi::c_int,
        w: ::core::ffi::c_int,
        h: ::core::ffi::c_int,
    );
    pub fn igImTextureDataQueueUpload(
        tex: *mut ImTextureData,
        x: ::core::ffi::c_int,
        y: ::core::ffi::c_int,
        w: ::core::ffi::c_int,
        h: ::core::ffi::c_int,
    );
    pub fn igImTextureDataGetFormatBytesPerPixel(format: ImTextureFormat) -> ::core::ffi::c_int;
    pub fn igImTextureDataGetStatusName(status: ImTextureStatus) -> *const ::core::ffi::c_char;
    pub fn igImTextureDataGetFormatName(format: ImTextureFormat) -> *const ::core::ffi::c_char;
    pub fn igImFontAtlasDebugLogTextureRequests(atlas: *mut ImFontAtlas);
    pub fn igImFontAtlasGetMouseCursorTexData(
        atlas: *mut ImFontAtlas,
        cursor_type: ImGuiMouseCursor,
        out_offset: *mut ImVec2_c,
        out_size: *mut ImVec2_c,
        out_uv_border: *mut ImVec2,
        out_uv_fill: *mut ImVec2,
    ) -> bool;
    #[doc = "hand written functions"]
    pub fn ImGuiTextBuffer_appendf(self_: *mut ImGuiTextBuffer, fmt: *const ::core::ffi::c_char, ...);
    pub fn igGET_FLT_MAX() -> f32;
    pub fn igGET_FLT_MIN() -> f32;
    pub fn ImVector_ImWchar_create() -> *mut ImVector_ImWchar;
    pub fn ImVector_ImWchar_destroy(self_: *mut ImVector_ImWchar);
    pub fn ImVector_ImWchar_Init(p: *mut ImVector_ImWchar);
    pub fn ImVector_ImWchar_UnInit(p: *mut ImVector_ImWchar);
}