// This file is automatically generated by generator.lua from
// https://github.com/cimgui/cimgui based on imgui.h file version "1.90.6" 19060
// from Dear ImGui https://github.com/ocornut/imgui with imgui_internal.h api
// docking branch
#define IMGUI_ENABLE_FREETYPE
#ifdef IMGUI_ENABLE_FREETYPE
#ifndef CIMGUI_FREETYPE
#error "IMGUI_FREETYPE should be defined for Freetype linking"
#endif
#else
#ifdef CIMGUI_FREETYPE
#error "IMGUI_FREETYPE should not be defined without freetype generated cimgui"
#endif
#endif
#include "imgui.h"
#ifdef IMGUI_ENABLE_FREETYPE
#include "misc/freetype/imgui_freetype.h"
#endif
#include "imgui_internal.h"

#include "cimgui.h"

CIMGUI_API ImVec2* ImVec2_ImVec2_Nil(void) {
  return IM_NEW(ImVec2)();
}
CIMGUI_API void ImVec2_destroy(ImVec2* self) {
  IM_DELETE(self);
}
CIMGUI_API ImVec2* ImVec2_ImVec2_Float(float _x, float _y) {
  return IM_NEW(ImVec2)(_x, _y);
}
CIMGUI_API ImVec4* ImVec4_ImVec4_Nil(void) {
  return IM_NEW(ImVec4)();
}
CIMGUI_API void ImVec4_destroy(ImVec4* self) {
  IM_DELETE(self);
}
CIMGUI_API ImVec4* ImVec4_ImVec4_Float(float _x, float _y, float _z, float _w) {
  return IM_NEW(ImVec4)(_x, _y, _z, _w);
}
CIMGUI_API ImGuiContext* igCreateContext(ImFontAtlas* shared_font_atlas) {
  return ImGui::CreateContext(shared_font_atlas);
}
CIMGUI_API void igDestroyContext(ImGuiContext* ctx) {
  return ImGui::DestroyContext(ctx);
}
CIMGUI_API ImGuiContext* igGetCurrentContext() {
  return ImGui::GetCurrentContext();
}
CIMGUI_API void igSetCurrentContext(ImGuiContext* ctx) {
  return ImGui::SetCurrentContext(ctx);
}
CIMGUI_API ImGuiIO* igGetIO() {
  return &ImGui::GetIO();
}
CIMGUI_API ImGuiStyle* igGetStyle() {
  return &ImGui::GetStyle();
}
CIMGUI_API void igNewFrame() {
  return ImGui::NewFrame();
}
CIMGUI_API void igEndFrame() {
  return ImGui::EndFrame();
}
CIMGUI_API void igRender() {
  return ImGui::Render();
}
CIMGUI_API ImDrawData* igGetDrawData() {
  return ImGui::GetDrawData();
}
CIMGUI_API void igShowDemoWindow(bool* p_open) {
  return ImGui::ShowDemoWindow(p_open);
}
CIMGUI_API void igShowMetricsWindow(bool* p_open) {
  return ImGui::ShowMetricsWindow(p_open);
}
CIMGUI_API void igShowDebugLogWindow(bool* p_open) {
  return ImGui::ShowDebugLogWindow(p_open);
}
CIMGUI_API void igShowIDStackToolWindow(bool* p_open) {
  return ImGui::ShowIDStackToolWindow(p_open);
}
CIMGUI_API void igShowAboutWindow(bool* p_open) {
  return ImGui::ShowAboutWindow(p_open);
}
CIMGUI_API void igShowStyleEditor(ImGuiStyle* ref) {
  return ImGui::ShowStyleEditor(ref);
}
CIMGUI_API bool igShowStyleSelector(const char* label) {
  return ImGui::ShowStyleSelector(label);
}
CIMGUI_API void igShowFontSelector(const char* label) {
  return ImGui::ShowFontSelector(label);
}
CIMGUI_API void igShowUserGuide() {
  return ImGui::ShowUserGuide();
}
CIMGUI_API const char* igGetVersion() {
  return ImGui::GetVersion();
}
CIMGUI_API void igStyleColorsDark(ImGuiStyle* dst) {
  return ImGui::StyleColorsDark(dst);
}
CIMGUI_API void igStyleColorsLight(ImGuiStyle* dst) {
  return ImGui::StyleColorsLight(dst);
}
CIMGUI_API void igStyleColorsClassic(ImGuiStyle* dst) {
  return ImGui::StyleColorsClassic(dst);
}
CIMGUI_API bool igBegin(const char* name,
                        bool* p_open,
                        ImGuiWindowFlags flags) {
  return ImGui::Begin(name, p_open, flags);
}
CIMGUI_API void igEnd() {
  return ImGui::End();
}
CIMGUI_API bool igBeginChild_Str(const char* str_id,
                                 const ImVec2 size,
                                 ImGuiChildFlags child_flags,
                                 ImGuiWindowFlags window_flags) {
  return ImGui::BeginChild(str_id, size, child_flags, window_flags);
}
CIMGUI_API bool igBeginChild_ID(ImGuiID id,
                                const ImVec2 size,
                                ImGuiChildFlags child_flags,
                                ImGuiWindowFlags window_flags) {
  return ImGui::BeginChild(id, size, child_flags, window_flags);
}
CIMGUI_API void igEndChild() {
  return ImGui::EndChild();
}
CIMGUI_API bool igIsWindowAppearing() {
  return ImGui::IsWindowAppearing();
}
CIMGUI_API bool igIsWindowCollapsed() {
  return ImGui::IsWindowCollapsed();
}
CIMGUI_API bool igIsWindowFocused(ImGuiFocusedFlags flags) {
  return ImGui::IsWindowFocused(flags);
}
CIMGUI_API bool igIsWindowHovered(ImGuiHoveredFlags flags) {
  return ImGui::IsWindowHovered(flags);
}
CIMGUI_API ImDrawList* igGetWindowDrawList() {
  return ImGui::GetWindowDrawList();
}
CIMGUI_API float igGetWindowDpiScale() {
  return ImGui::GetWindowDpiScale();
}
CIMGUI_API void igGetWindowPos(ImVec2* pOut) {
  *pOut = ImGui::GetWindowPos();
}
CIMGUI_API void igGetWindowSize(ImVec2* pOut) {
  *pOut = ImGui::GetWindowSize();
}
CIMGUI_API float igGetWindowWidth() {
  return ImGui::GetWindowWidth();
}
CIMGUI_API float igGetWindowHeight() {
  return ImGui::GetWindowHeight();
}
CIMGUI_API ImGuiViewport* igGetWindowViewport() {
  return ImGui::GetWindowViewport();
}
CIMGUI_API void igSetNextWindowPos(const ImVec2 pos,
                                   ImGuiCond cond,
                                   const ImVec2 pivot) {
  return ImGui::SetNextWindowPos(pos, cond, pivot);
}
CIMGUI_API void igSetNextWindowSize(const ImVec2 size, ImGuiCond cond) {
  return ImGui::SetNextWindowSize(size, cond);
}
CIMGUI_API void igSetNextWindowSizeConstraints(
    const ImVec2 size_min,
    const ImVec2 size_max,
    ImGuiSizeCallback custom_callback,
    void* custom_callback_data) {
  return ImGui::SetNextWindowSizeConstraints(
      size_min, size_max, custom_callback, custom_callback_data);
}
CIMGUI_API void igSetNextWindowContentSize(const ImVec2 size) {
  return ImGui::SetNextWindowContentSize(size);
}
CIMGUI_API void igSetNextWindowCollapsed(bool collapsed, ImGuiCond cond) {
  return ImGui::SetNextWindowCollapsed(collapsed, cond);
}
CIMGUI_API void igSetNextWindowFocus() {
  return ImGui::SetNextWindowFocus();
}
CIMGUI_API void igSetNextWindowScroll(const ImVec2 scroll) {
  return ImGui::SetNextWindowScroll(scroll);
}
CIMGUI_API void igSetNextWindowBgAlpha(float alpha) {
  return ImGui::SetNextWindowBgAlpha(alpha);
}
CIMGUI_API void igSetNextWindowViewport(ImGuiID viewport_id) {
  return ImGui::SetNextWindowViewport(viewport_id);
}
CIMGUI_API void igSetWindowPos_Vec2(const ImVec2 pos, ImGuiCond cond) {
  return ImGui::SetWindowPos(pos, cond);
}
CIMGUI_API void igSetWindowSize_Vec2(const ImVec2 size, ImGuiCond cond) {
  return ImGui::SetWindowSize(size, cond);
}
CIMGUI_API void igSetWindowCollapsed_Bool(bool collapsed, ImGuiCond cond) {
  return ImGui::SetWindowCollapsed(collapsed, cond);
}
CIMGUI_API void igSetWindowFocus_Nil() {
  return ImGui::SetWindowFocus();
}
CIMGUI_API void igSetWindowFontScale(float scale) {
  return ImGui::SetWindowFontScale(scale);
}
CIMGUI_API void igSetWindowPos_Str(const char* name,
                                   const ImVec2 pos,
                                   ImGuiCond cond) {
  return ImGui::SetWindowPos(name, pos, cond);
}
CIMGUI_API void igSetWindowSize_Str(const char* name,
                                    const ImVec2 size,
                                    ImGuiCond cond) {
  return ImGui::SetWindowSize(name, size, cond);
}
CIMGUI_API void igSetWindowCollapsed_Str(const char* name,
                                         bool collapsed,
                                         ImGuiCond cond) {
  return ImGui::SetWindowCollapsed(name, collapsed, cond);
}
CIMGUI_API void igSetWindowFocus_Str(const char* name) {
  return ImGui::SetWindowFocus(name);
}
CIMGUI_API void igGetContentRegionAvail(ImVec2* pOut) {
  *pOut = ImGui::GetContentRegionAvail();
}
CIMGUI_API void igGetContentRegionMax(ImVec2* pOut) {
  *pOut = ImGui::GetContentRegionMax();
}
CIMGUI_API void igGetWindowContentRegionMin(ImVec2* pOut) {
  *pOut = ImGui::GetWindowContentRegionMin();
}
CIMGUI_API void igGetWindowContentRegionMax(ImVec2* pOut) {
  *pOut = ImGui::GetWindowContentRegionMax();
}
CIMGUI_API float igGetScrollX() {
  return ImGui::GetScrollX();
}
CIMGUI_API float igGetScrollY() {
  return ImGui::GetScrollY();
}
CIMGUI_API void igSetScrollX_Float(float scroll_x) {
  return ImGui::SetScrollX(scroll_x);
}
CIMGUI_API void igSetScrollY_Float(float scroll_y) {
  return ImGui::SetScrollY(scroll_y);
}
CIMGUI_API float igGetScrollMaxX() {
  return ImGui::GetScrollMaxX();
}
CIMGUI_API float igGetScrollMaxY() {
  return ImGui::GetScrollMaxY();
}
CIMGUI_API void igSetScrollHereX(float center_x_ratio) {
  return ImGui::SetScrollHereX(center_x_ratio);
}
CIMGUI_API void igSetScrollHereY(float center_y_ratio) {
  return ImGui::SetScrollHereY(center_y_ratio);
}
CIMGUI_API void igSetScrollFromPosX_Float(float local_x, float center_x_ratio) {
  return ImGui::SetScrollFromPosX(local_x, center_x_ratio);
}
CIMGUI_API void igSetScrollFromPosY_Float(float local_y, float center_y_ratio) {
  return ImGui::SetScrollFromPosY(local_y, center_y_ratio);
}
CIMGUI_API void igPushFont(ImFont* font) {
  return ImGui::PushFont(font);
}
CIMGUI_API void igPopFont() {
  return ImGui::PopFont();
}
CIMGUI_API void igPushStyleColor_U32(ImGuiCol idx, ImU32 col) {
  return ImGui::PushStyleColor(idx, col);
}
CIMGUI_API void igPushStyleColor_Vec4(ImGuiCol idx, const ImVec4 col) {
  return ImGui::PushStyleColor(idx, col);
}
CIMGUI_API void igPopStyleColor(int count) {
  return ImGui::PopStyleColor(count);
}
CIMGUI_API void igPushStyleVar_Float(ImGuiStyleVar idx, float val) {
  return ImGui::PushStyleVar(idx, val);
}
CIMGUI_API void igPushStyleVar_Vec2(ImGuiStyleVar idx, const ImVec2 val) {
  return ImGui::PushStyleVar(idx, val);
}
CIMGUI_API void igPopStyleVar(int count) {
  return ImGui::PopStyleVar(count);
}
CIMGUI_API void igPushTabStop(bool tab_stop) {
  return ImGui::PushTabStop(tab_stop);
}
CIMGUI_API void igPopTabStop() {
  return ImGui::PopTabStop();
}
CIMGUI_API void igPushButtonRepeat(bool repeat) {
  return ImGui::PushButtonRepeat(repeat);
}
CIMGUI_API void igPopButtonRepeat() {
  return ImGui::PopButtonRepeat();
}
CIMGUI_API void igPushItemWidth(float item_width) {
  return ImGui::PushItemWidth(item_width);
}
CIMGUI_API void igPopItemWidth() {
  return ImGui::PopItemWidth();
}
CIMGUI_API void igSetNextItemWidth(float item_width) {
  return ImGui::SetNextItemWidth(item_width);
}
CIMGUI_API float igCalcItemWidth() {
  return ImGui::CalcItemWidth();
}
CIMGUI_API void igPushTextWrapPos(float wrap_local_pos_x) {
  return ImGui::PushTextWrapPos(wrap_local_pos_x);
}
CIMGUI_API void igPopTextWrapPos() {
  return ImGui::PopTextWrapPos();
}
CIMGUI_API ImFont* igGetFont() {
  return ImGui::GetFont();
}
CIMGUI_API float igGetFontSize() {
  return ImGui::GetFontSize();
}
CIMGUI_API void igGetFontTexUvWhitePixel(ImVec2* pOut) {
  *pOut = ImGui::GetFontTexUvWhitePixel();
}
CIMGUI_API ImU32 igGetColorU32_Col(ImGuiCol idx, float alpha_mul) {
  return ImGui::GetColorU32(idx, alpha_mul);
}
CIMGUI_API ImU32 igGetColorU32_Vec4(const ImVec4 col) {
  return ImGui::GetColorU32(col);
}
CIMGUI_API ImU32 igGetColorU32_U32(ImU32 col, float alpha_mul) {
  return ImGui::GetColorU32(col, alpha_mul);
}
CIMGUI_API const ImVec4* igGetStyleColorVec4(ImGuiCol idx) {
  return &ImGui::GetStyleColorVec4(idx);
}
CIMGUI_API void igGetCursorScreenPos(ImVec2* pOut) {
  *pOut = ImGui::GetCursorScreenPos();
}
CIMGUI_API void igSetCursorScreenPos(const ImVec2 pos) {
  return ImGui::SetCursorScreenPos(pos);
}
CIMGUI_API void igGetCursorPos(ImVec2* pOut) {
  *pOut = ImGui::GetCursorPos();
}
CIMGUI_API float igGetCursorPosX() {
  return ImGui::GetCursorPosX();
}
CIMGUI_API float igGetCursorPosY() {
  return ImGui::GetCursorPosY();
}
CIMGUI_API void igSetCursorPos(const ImVec2 local_pos) {
  return ImGui::SetCursorPos(local_pos);
}
CIMGUI_API void igSetCursorPosX(float local_x) {
  return ImGui::SetCursorPosX(local_x);
}
CIMGUI_API void igSetCursorPosY(float local_y) {
  return ImGui::SetCursorPosY(local_y);
}
CIMGUI_API void igGetCursorStartPos(ImVec2* pOut) {
  *pOut = ImGui::GetCursorStartPos();
}
CIMGUI_API void igSeparator() {
  return ImGui::Separator();
}
CIMGUI_API void igSameLine(float offset_from_start_x, float spacing) {
  return ImGui::SameLine(offset_from_start_x, spacing);
}
CIMGUI_API void igNewLine() {
  return ImGui::NewLine();
}
CIMGUI_API void igSpacing() {
  return ImGui::Spacing();
}
CIMGUI_API void igDummy(const ImVec2 size) {
  return ImGui::Dummy(size);
}
CIMGUI_API void igIndent(float indent_w) {
  return ImGui::Indent(indent_w);
}
CIMGUI_API void igUnindent(float indent_w) {
  return ImGui::Unindent(indent_w);
}
CIMGUI_API void igBeginGroup() {
  return ImGui::BeginGroup();
}
CIMGUI_API void igEndGroup() {
  return ImGui::EndGroup();
}
CIMGUI_API void igAlignTextToFramePadding() {
  return ImGui::AlignTextToFramePadding();
}
CIMGUI_API float igGetTextLineHeight() {
  return ImGui::GetTextLineHeight();
}
CIMGUI_API float igGetTextLineHeightWithSpacing() {
  return ImGui::GetTextLineHeightWithSpacing();
}
CIMGUI_API float igGetFrameHeight() {
  return ImGui::GetFrameHeight();
}
CIMGUI_API float igGetFrameHeightWithSpacing() {
  return ImGui::GetFrameHeightWithSpacing();
}
CIMGUI_API void igPushID_Str(const char* str_id) {
  return ImGui::PushID(str_id);
}
CIMGUI_API void igPushID_StrStr(const char* str_id_begin,
                                const char* str_id_end) {
  return ImGui::PushID(str_id_begin, str_id_end);
}
CIMGUI_API void igPushID_Ptr(const void* ptr_id) {
  return ImGui::PushID(ptr_id);
}
CIMGUI_API void igPushID_Int(int int_id) {
  return ImGui::PushID(int_id);
}
CIMGUI_API void igPopID() {
  return ImGui::PopID();
}
CIMGUI_API ImGuiID igGetID_Str(const char* str_id) {
  return ImGui::GetID(str_id);
}
CIMGUI_API ImGuiID igGetID_StrStr(const char* str_id_begin,
                                  const char* str_id_end) {
  return ImGui::GetID(str_id_begin, str_id_end);
}
CIMGUI_API ImGuiID igGetID_Ptr(const void* ptr_id) {
  return ImGui::GetID(ptr_id);
}
CIMGUI_API void igTextUnformatted(const char* text, const char* text_end) {
  return ImGui::TextUnformatted(text, text_end);
}
CIMGUI_API void igText(const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);
  ImGui::TextV(fmt, args);
  va_end(args);
}
CIMGUI_API void igTextV(const char* fmt, va_list args) {
  return ImGui::TextV(fmt, args);
}
CIMGUI_API void igTextColored(const ImVec4 col, const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);
  ImGui::TextColoredV(col, fmt, args);
  va_end(args);
}
CIMGUI_API void igTextColoredV(const ImVec4 col,
                               const char* fmt,
                               va_list args) {
  return ImGui::TextColoredV(col, fmt, args);
}
CIMGUI_API void igTextDisabled(const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);
  ImGui::TextDisabledV(fmt, args);
  va_end(args);
}
CIMGUI_API void igTextDisabledV(const char* fmt, va_list args) {
  return ImGui::TextDisabledV(fmt, args);
}
CIMGUI_API void igTextWrapped(const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);
  ImGui::TextWrappedV(fmt, args);
  va_end(args);
}
CIMGUI_API void igTextWrappedV(const char* fmt, va_list args) {
  return ImGui::TextWrappedV(fmt, args);
}
CIMGUI_API void igLabelText(const char* label, const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);
  ImGui::LabelTextV(label, fmt, args);
  va_end(args);
}
CIMGUI_API void igLabelTextV(const char* label, const char* fmt, va_list args) {
  return ImGui::LabelTextV(label, fmt, args);
}
CIMGUI_API void igBulletText(const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);
  ImGui::BulletTextV(fmt, args);
  va_end(args);
}
CIMGUI_API void igBulletTextV(const char* fmt, va_list args) {
  return ImGui::BulletTextV(fmt, args);
}
CIMGUI_API void igSeparatorText(const char* label) {
  return ImGui::SeparatorText(label);
}
CIMGUI_API bool igButton(const char* label, const ImVec2 size) {
  return ImGui::Button(label, size);
}
CIMGUI_API bool igSmallButton(const char* label) {
  return ImGui::SmallButton(label);
}
CIMGUI_API bool igInvisibleButton(const char* str_id,
                                  const ImVec2 size,
                                  ImGuiButtonFlags flags) {
  return ImGui::InvisibleButton(str_id, size, flags);
}
CIMGUI_API bool igArrowButton(const char* str_id, ImGuiDir dir) {
  return ImGui::ArrowButton(str_id, dir);
}
CIMGUI_API bool igCheckbox(const char* label, bool* v) {
  return ImGui::Checkbox(label, v);
}
CIMGUI_API bool igCheckboxFlags_IntPtr(const char* label,
                                       int* flags,
                                       int flags_value) {
  return ImGui::CheckboxFlags(label, flags, flags_value);
}
CIMGUI_API bool igCheckboxFlags_UintPtr(const char* label,
                                        unsigned int* flags,
                                        unsigned int flags_value) {
  return ImGui::CheckboxFlags(label, flags, flags_value);
}
CIMGUI_API bool igRadioButton_Bool(const char* label, bool active) {
  return ImGui::RadioButton(label, active);
}
CIMGUI_API bool igRadioButton_IntPtr(const char* label, int* v, int v_button) {
  return ImGui::RadioButton(label, v, v_button);
}
CIMGUI_API void igProgressBar(float fraction,
                              const ImVec2 size_arg,
                              const char* overlay) {
  return ImGui::ProgressBar(fraction, size_arg, overlay);
}
CIMGUI_API void igBullet() {
  return ImGui::Bullet();
}
CIMGUI_API void igImage(ImTextureID user_texture_id,
                        const ImVec2 image_size,
                        const ImVec2 uv0,
                        const ImVec2 uv1,
                        const ImVec4 tint_col,
                        const ImVec4 border_col) {
  return ImGui::Image(user_texture_id, image_size, uv0, uv1, tint_col,
                      border_col);
}
CIMGUI_API bool igImageButton(const char* str_id,
                              ImTextureID user_texture_id,
                              const ImVec2 image_size,
                              const ImVec2 uv0,
                              const ImVec2 uv1,
                              const ImVec4 bg_col,
                              const ImVec4 tint_col) {
  return ImGui::ImageButton(str_id, user_texture_id, image_size, uv0, uv1,
                            bg_col, tint_col);
}
CIMGUI_API bool igBeginCombo(const char* label,
                             const char* preview_value,
                             ImGuiComboFlags flags) {
  return ImGui::BeginCombo(label, preview_value, flags);
}
CIMGUI_API void igEndCombo() {
  return ImGui::EndCombo();
}
CIMGUI_API bool igCombo_Str_arr(const char* label,
                                int* current_item,
                                const char* const items[],
                                int items_count,
                                int popup_max_height_in_items) {
  return ImGui::Combo(label, current_item, items, items_count,
                      popup_max_height_in_items);
}
CIMGUI_API bool igCombo_Str(const char* label,
                            int* current_item,
                            const char* items_separated_by_zeros,
                            int popup_max_height_in_items) {
  return ImGui::Combo(label, current_item, items_separated_by_zeros,
                      popup_max_height_in_items);
}
CIMGUI_API bool igCombo_FnStrPtr(const char* label,
                                 int* current_item,
                                 const char* (*getter)(void* user_data,
                                                       int idx),
                                 void* user_data,
                                 int items_count,
                                 int popup_max_height_in_items) {
  return ImGui::Combo(label, current_item, getter, user_data, items_count,
                      popup_max_height_in_items);
}
CIMGUI_API bool igDragFloat(const char* label,
                            float* v,
                            float v_speed,
                            float v_min,
                            float v_max,
                            const char* format,
                            ImGuiSliderFlags flags) {
  return ImGui::DragFloat(label, v, v_speed, v_min, v_max, format, flags);
}
CIMGUI_API bool igDragFloat2(const char* label,
                             float v[2],
                             float v_speed,
                             float v_min,
                             float v_max,
                             const char* format,
                             ImGuiSliderFlags flags) {
  return ImGui::DragFloat2(label, v, v_speed, v_min, v_max, format, flags);
}
CIMGUI_API bool igDragFloat3(const char* label,
                             float v[3],
                             float v_speed,
                             float v_min,
                             float v_max,
                             const char* format,
                             ImGuiSliderFlags flags) {
  return ImGui::DragFloat3(label, v, v_speed, v_min, v_max, format, flags);
}
CIMGUI_API bool igDragFloat4(const char* label,
                             float v[4],
                             float v_speed,
                             float v_min,
                             float v_max,
                             const char* format,
                             ImGuiSliderFlags flags) {
  return ImGui::DragFloat4(label, v, v_speed, v_min, v_max, format, flags);
}
CIMGUI_API bool igDragFloatRange2(const char* label,
                                  float* v_current_min,
                                  float* v_current_max,
                                  float v_speed,
                                  float v_min,
                                  float v_max,
                                  const char* format,
                                  const char* format_max,
                                  ImGuiSliderFlags flags) {
  return ImGui::DragFloatRange2(label, v_current_min, v_current_max, v_speed,
                                v_min, v_max, format, format_max, flags);
}
CIMGUI_API bool igDragInt(const char* label,
                          int* v,
                          float v_speed,
                          int v_min,
                          int v_max,
                          const char* format,
                          ImGuiSliderFlags flags) {
  return ImGui::DragInt(label, v, v_speed, v_min, v_max, format, flags);
}
CIMGUI_API bool igDragInt2(const char* label,
                           int v[2],
                           float v_speed,
                           int v_min,
                           int v_max,
                           const char* format,
                           ImGuiSliderFlags flags) {
  return ImGui::DragInt2(label, v, v_speed, v_min, v_max, format, flags);
}
CIMGUI_API bool igDragInt3(const char* label,
                           int v[3],
                           float v_speed,
                           int v_min,
                           int v_max,
                           const char* format,
                           ImGuiSliderFlags flags) {
  return ImGui::DragInt3(label, v, v_speed, v_min, v_max, format, flags);
}
CIMGUI_API bool igDragInt4(const char* label,
                           int v[4],
                           float v_speed,
                           int v_min,
                           int v_max,
                           const char* format,
                           ImGuiSliderFlags flags) {
  return ImGui::DragInt4(label, v, v_speed, v_min, v_max, format, flags);
}
CIMGUI_API bool igDragIntRange2(const char* label,
                                int* v_current_min,
                                int* v_current_max,
                                float v_speed,
                                int v_min,
                                int v_max,
                                const char* format,
                                const char* format_max,
                                ImGuiSliderFlags flags) {
  return ImGui::DragIntRange2(label, v_current_min, v_current_max, v_speed,
                              v_min, v_max, format, format_max, flags);
}
CIMGUI_API bool igDragScalar(const char* label,
                             ImGuiDataType data_type,
                             void* p_data,
                             float v_speed,
                             const void* p_min,
                             const void* p_max,
                             const char* format,
                             ImGuiSliderFlags flags) {
  return ImGui::DragScalar(label, data_type, p_data, v_speed, p_min, p_max,
                           format, flags);
}
CIMGUI_API bool igDragScalarN(const char* label,
                              ImGuiDataType data_type,
                              void* p_data,
                              int components,
                              float v_speed,
                              const void* p_min,
                              const void* p_max,
                              const char* format,
                              ImGuiSliderFlags flags) {
  return ImGui::DragScalarN(label, data_type, p_data, components, v_speed,
                            p_min, p_max, format, flags);
}
CIMGUI_API bool igSliderFloat(const char* label,
                              float* v,
                              float v_min,
                              float v_max,
                              const char* format,
                              ImGuiSliderFlags flags) {
  return ImGui::SliderFloat(label, v, v_min, v_max, format, flags);
}
CIMGUI_API bool igSliderFloat2(const char* label,
                               float v[2],
                               float v_min,
                               float v_max,
                               const char* format,
                               ImGuiSliderFlags flags) {
  return ImGui::SliderFloat2(label, v, v_min, v_max, format, flags);
}
CIMGUI_API bool igSliderFloat3(const char* label,
                               float v[3],
                               float v_min,
                               float v_max,
                               const char* format,
                               ImGuiSliderFlags flags) {
  return ImGui::SliderFloat3(label, v, v_min, v_max, format, flags);
}
CIMGUI_API bool igSliderFloat4(const char* label,
                               float v[4],
                               float v_min,
                               float v_max,
                               const char* format,
                               ImGuiSliderFlags flags) {
  return ImGui::SliderFloat4(label, v, v_min, v_max, format, flags);
}
CIMGUI_API bool igSliderAngle(const char* label,
                              float* v_rad,
                              float v_degrees_min,
                              float v_degrees_max,
                              const char* format,
                              ImGuiSliderFlags flags) {
  return ImGui::SliderAngle(label, v_rad, v_degrees_min, v_degrees_max, format,
                            flags);
}
CIMGUI_API bool igSliderInt(const char* label,
                            int* v,
                            int v_min,
                            int v_max,
                            const char* format,
                            ImGuiSliderFlags flags) {
  return ImGui::SliderInt(label, v, v_min, v_max, format, flags);
}
CIMGUI_API bool igSliderInt2(const char* label,
                             int v[2],
                             int v_min,
                             int v_max,
                             const char* format,
                             ImGuiSliderFlags flags) {
  return ImGui::SliderInt2(label, v, v_min, v_max, format, flags);
}
CIMGUI_API bool igSliderInt3(const char* label,
                             int v[3],
                             int v_min,
                             int v_max,
                             const char* format,
                             ImGuiSliderFlags flags) {
  return ImGui::SliderInt3(label, v, v_min, v_max, format, flags);
}
CIMGUI_API bool igSliderInt4(const char* label,
                             int v[4],
                             int v_min,
                             int v_max,
                             const char* format,
                             ImGuiSliderFlags flags) {
  return ImGui::SliderInt4(label, v, v_min, v_max, format, flags);
}
CIMGUI_API bool igSliderScalar(const char* label,
                               ImGuiDataType data_type,
                               void* p_data,
                               const void* p_min,
                               const void* p_max,
                               const char* format,
                               ImGuiSliderFlags flags) {
  return ImGui::SliderScalar(label, data_type, p_data, p_min, p_max, format,
                             flags);
}
CIMGUI_API bool igSliderScalarN(const char* label,
                                ImGuiDataType data_type,
                                void* p_data,
                                int components,
                                const void* p_min,
                                const void* p_max,
                                const char* format,
                                ImGuiSliderFlags flags) {
  return ImGui::SliderScalarN(label, data_type, p_data, components, p_min,
                              p_max, format, flags);
}
CIMGUI_API bool igVSliderFloat(const char* label,
                               const ImVec2 size,
                               float* v,
                               float v_min,
                               float v_max,
                               const char* format,
                               ImGuiSliderFlags flags) {
  return ImGui::VSliderFloat(label, size, v, v_min, v_max, format, flags);
}
CIMGUI_API bool igVSliderInt(const char* label,
                             const ImVec2 size,
                             int* v,
                             int v_min,
                             int v_max,
                             const char* format,
                             ImGuiSliderFlags flags) {
  return ImGui::VSliderInt(label, size, v, v_min, v_max, format, flags);
}
CIMGUI_API bool igVSliderScalar(const char* label,
                                const ImVec2 size,
                                ImGuiDataType data_type,
                                void* p_data,
                                const void* p_min,
                                const void* p_max,
                                const char* format,
                                ImGuiSliderFlags flags) {
  return ImGui::VSliderScalar(label, size, data_type, p_data, p_min, p_max,
                              format, flags);
}
CIMGUI_API bool igInputText(const char* label,
                            char* buf,
                            size_t buf_size,
                            ImGuiInputTextFlags flags,
                            ImGuiInputTextCallback callback,
                            void* user_data) {
  return ImGui::InputText(label, buf, buf_size, flags, callback, user_data);
}
CIMGUI_API bool igInputTextMultiline(const char* label,
                                     char* buf,
                                     size_t buf_size,
                                     const ImVec2 size,
                                     ImGuiInputTextFlags flags,
                                     ImGuiInputTextCallback callback,
                                     void* user_data) {
  return ImGui::InputTextMultiline(label, buf, buf_size, size, flags, callback,
                                   user_data);
}
CIMGUI_API bool igInputTextWithHint(const char* label,
                                    const char* hint,
                                    char* buf,
                                    size_t buf_size,
                                    ImGuiInputTextFlags flags,
                                    ImGuiInputTextCallback callback,
                                    void* user_data) {
  return ImGui::InputTextWithHint(label, hint, buf, buf_size, flags, callback,
                                  user_data);
}
CIMGUI_API bool igInputFloat(const char* label,
                             float* v,
                             float step,
                             float step_fast,
                             const char* format,
                             ImGuiInputTextFlags flags) {
  return ImGui::InputFloat(label, v, step, step_fast, format, flags);
}
CIMGUI_API bool igInputFloat2(const char* label,
                              float v[2],
                              const char* format,
                              ImGuiInputTextFlags flags) {
  return ImGui::InputFloat2(label, v, format, flags);
}
CIMGUI_API bool igInputFloat3(const char* label,
                              float v[3],
                              const char* format,
                              ImGuiInputTextFlags flags) {
  return ImGui::InputFloat3(label, v, format, flags);
}
CIMGUI_API bool igInputFloat4(const char* label,
                              float v[4],
                              const char* format,
                              ImGuiInputTextFlags flags) {
  return ImGui::InputFloat4(label, v, format, flags);
}
CIMGUI_API bool igInputInt(const char* label,
                           int* v,
                           int step,
                           int step_fast,
                           ImGuiInputTextFlags flags) {
  return ImGui::InputInt(label, v, step, step_fast, flags);
}
CIMGUI_API bool igInputInt2(const char* label,
                            int v[2],
                            ImGuiInputTextFlags flags) {
  return ImGui::InputInt2(label, v, flags);
}
CIMGUI_API bool igInputInt3(const char* label,
                            int v[3],
                            ImGuiInputTextFlags flags) {
  return ImGui::InputInt3(label, v, flags);
}
CIMGUI_API bool igInputInt4(const char* label,
                            int v[4],
                            ImGuiInputTextFlags flags) {
  return ImGui::InputInt4(label, v, flags);
}
CIMGUI_API bool igInputDouble(const char* label,
                              double* v,
                              double step,
                              double step_fast,
                              const char* format,
                              ImGuiInputTextFlags flags) {
  return ImGui::InputDouble(label, v, step, step_fast, format, flags);
}
CIMGUI_API bool igInputScalar(const char* label,
                              ImGuiDataType data_type,
                              void* p_data,
                              const void* p_step,
                              const void* p_step_fast,
                              const char* format,
                              ImGuiInputTextFlags flags) {
  return ImGui::InputScalar(label, data_type, p_data, p_step, p_step_fast,
                            format, flags);
}
CIMGUI_API bool igInputScalarN(const char* label,
                               ImGuiDataType data_type,
                               void* p_data,
                               int components,
                               const void* p_step,
                               const void* p_step_fast,
                               const char* format,
                               ImGuiInputTextFlags flags) {
  return ImGui::InputScalarN(label, data_type, p_data, components, p_step,
                             p_step_fast, format, flags);
}
CIMGUI_API bool igColorEdit3(const char* label,
                             float col[3],
                             ImGuiColorEditFlags flags) {
  return ImGui::ColorEdit3(label, col, flags);
}
CIMGUI_API bool igColorEdit4(const char* label,
                             float col[4],
                             ImGuiColorEditFlags flags) {
  return ImGui::ColorEdit4(label, col, flags);
}
CIMGUI_API bool igColorPicker3(const char* label,
                               float col[3],
                               ImGuiColorEditFlags flags) {
  return ImGui::ColorPicker3(label, col, flags);
}
CIMGUI_API bool igColorPicker4(const char* label,
                               float col[4],
                               ImGuiColorEditFlags flags,
                               const float* ref_col) {
  return ImGui::ColorPicker4(label, col, flags, ref_col);
}
CIMGUI_API bool igColorButton(const char* desc_id,
                              const ImVec4 col,
                              ImGuiColorEditFlags flags,
                              const ImVec2 size) {
  return ImGui::ColorButton(desc_id, col, flags, size);
}
CIMGUI_API void igSetColorEditOptions(ImGuiColorEditFlags flags) {
  return ImGui::SetColorEditOptions(flags);
}
CIMGUI_API bool igTreeNode_Str(const char* label) {
  return ImGui::TreeNode(label);
}
CIMGUI_API bool igTreeNode_StrStr(const char* str_id, const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);
  bool ret = ImGui::TreeNodeV(str_id, fmt, args);
  va_end(args);
  return ret;
}
CIMGUI_API bool igTreeNode_Ptr(const void* ptr_id, const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);
  bool ret = ImGui::TreeNodeV(ptr_id, fmt, args);
  va_end(args);
  return ret;
}
CIMGUI_API bool igTreeNodeV_Str(const char* str_id,
                                const char* fmt,
                                va_list args) {
  return ImGui::TreeNodeV(str_id, fmt, args);
}
CIMGUI_API bool igTreeNodeV_Ptr(const void* ptr_id,
                                const char* fmt,
                                va_list args) {
  return ImGui::TreeNodeV(ptr_id, fmt, args);
}
CIMGUI_API bool igTreeNodeEx_Str(const char* label, ImGuiTreeNodeFlags flags) {
  return ImGui::TreeNodeEx(label, flags);
}
CIMGUI_API bool igTreeNodeEx_StrStr(const char* str_id,
                                    ImGuiTreeNodeFlags flags,
                                    const char* fmt,
                                    ...) {
  va_list args;
  va_start(args, fmt);
  bool ret = ImGui::TreeNodeExV(str_id, flags, fmt, args);
  va_end(args);
  return ret;
}
CIMGUI_API bool igTreeNodeEx_Ptr(const void* ptr_id,
                                 ImGuiTreeNodeFlags flags,
                                 const char* fmt,
                                 ...) {
  va_list args;
  va_start(args, fmt);
  bool ret = ImGui::TreeNodeExV(ptr_id, flags, fmt, args);
  va_end(args);
  return ret;
}
CIMGUI_API bool igTreeNodeExV_Str(const char* str_id,
                                  ImGuiTreeNodeFlags flags,
                                  const char* fmt,
                                  va_list args) {
  return ImGui::TreeNodeExV(str_id, flags, fmt, args);
}
CIMGUI_API bool igTreeNodeExV_Ptr(const void* ptr_id,
                                  ImGuiTreeNodeFlags flags,
                                  const char* fmt,
                                  va_list args) {
  return ImGui::TreeNodeExV(ptr_id, flags, fmt, args);
}
CIMGUI_API void igTreePush_Str(const char* str_id) {
  return ImGui::TreePush(str_id);
}
CIMGUI_API void igTreePush_Ptr(const void* ptr_id) {
  return ImGui::TreePush(ptr_id);
}
CIMGUI_API void igTreePop() {
  return ImGui::TreePop();
}
CIMGUI_API float igGetTreeNodeToLabelSpacing() {
  return ImGui::GetTreeNodeToLabelSpacing();
}
CIMGUI_API bool igCollapsingHeader_TreeNodeFlags(const char* label,
                                                 ImGuiTreeNodeFlags flags) {
  return ImGui::CollapsingHeader(label, flags);
}
CIMGUI_API bool igCollapsingHeader_BoolPtr(const char* label,
                                           bool* p_visible,
                                           ImGuiTreeNodeFlags flags) {
  return ImGui::CollapsingHeader(label, p_visible, flags);
}
CIMGUI_API void igSetNextItemOpen(bool is_open, ImGuiCond cond) {
  return ImGui::SetNextItemOpen(is_open, cond);
}
CIMGUI_API bool igSelectable_Bool(const char* label,
                                  bool selected,
                                  ImGuiSelectableFlags flags,
                                  const ImVec2 size) {
  return ImGui::Selectable(label, selected, flags, size);
}
CIMGUI_API bool igSelectable_BoolPtr(const char* label,
                                     bool* p_selected,
                                     ImGuiSelectableFlags flags,
                                     const ImVec2 size) {
  return ImGui::Selectable(label, p_selected, flags, size);
}
CIMGUI_API bool igBeginListBox(const char* label, const ImVec2 size) {
  return ImGui::BeginListBox(label, size);
}
CIMGUI_API void igEndListBox() {
  return ImGui::EndListBox();
}
CIMGUI_API bool igListBox_Str_arr(const char* label,
                                  int* current_item,
                                  const char* const items[],
                                  int items_count,
                                  int height_in_items) {
  return ImGui::ListBox(label, current_item, items, items_count,
                        height_in_items);
}
CIMGUI_API bool igListBox_FnStrPtr(const char* label,
                                   int* current_item,
                                   const char* (*getter)(void* user_data,
                                                         int idx),
                                   void* user_data,
                                   int items_count,
                                   int height_in_items) {
  return ImGui::ListBox(label, current_item, getter, user_data, items_count,
                        height_in_items);
}
CIMGUI_API void igPlotLines_FloatPtr(const char* label,
                                     const float* values,
                                     int values_count,
                                     int values_offset,
                                     const char* overlay_text,
                                     float scale_min,
                                     float scale_max,
                                     ImVec2 graph_size,
                                     int stride) {
  return ImGui::PlotLines(label, values, values_count, values_offset,
                          overlay_text, scale_min, scale_max, graph_size,
                          stride);
}
CIMGUI_API void igPlotLines_FnFloatPtr(const char* label,
                                       float (*values_getter)(void* data,
                                                              int idx),
                                       void* data,
                                       int values_count,
                                       int values_offset,
                                       const char* overlay_text,
                                       float scale_min,
                                       float scale_max,
                                       ImVec2 graph_size) {
  return ImGui::PlotLines(label, values_getter, data, values_count,
                          values_offset, overlay_text, scale_min, scale_max,
                          graph_size);
}
CIMGUI_API void igPlotHistogram_FloatPtr(const char* label,
                                         const float* values,
                                         int values_count,
                                         int values_offset,
                                         const char* overlay_text,
                                         float scale_min,
                                         float scale_max,
                                         ImVec2 graph_size,
                                         int stride) {
  return ImGui::PlotHistogram(label, values, values_count, values_offset,
                              overlay_text, scale_min, scale_max, graph_size,
                              stride);
}
CIMGUI_API void igPlotHistogram_FnFloatPtr(const char* label,
                                           float (*values_getter)(void* data,
                                                                  int idx),
                                           void* data,
                                           int values_count,
                                           int values_offset,
                                           const char* overlay_text,
                                           float scale_min,
                                           float scale_max,
                                           ImVec2 graph_size) {
  return ImGui::PlotHistogram(label, values_getter, data, values_count,
                              values_offset, overlay_text, scale_min, scale_max,
                              graph_size);
}
CIMGUI_API void igValue_Bool(const char* prefix, bool b) {
  return ImGui::Value(prefix, b);
}
CIMGUI_API void igValue_Int(const char* prefix, int v) {
  return ImGui::Value(prefix, v);
}
CIMGUI_API void igValue_Uint(const char* prefix, unsigned int v) {
  return ImGui::Value(prefix, v);
}
CIMGUI_API void igValue_Float(const char* prefix,
                              float v,
                              const char* float_format) {
  return ImGui::Value(prefix, v, float_format);
}
CIMGUI_API bool igBeginMenuBar() {
  return ImGui::BeginMenuBar();
}
CIMGUI_API void igEndMenuBar() {
  return ImGui::EndMenuBar();
}
CIMGUI_API bool igBeginMainMenuBar() {
  return ImGui::BeginMainMenuBar();
}
CIMGUI_API void igEndMainMenuBar() {
  return ImGui::EndMainMenuBar();
}
CIMGUI_API bool igBeginMenu(const char* label, bool enabled) {
  return ImGui::BeginMenu(label, enabled);
}
CIMGUI_API void igEndMenu() {
  return ImGui::EndMenu();
}
CIMGUI_API bool igMenuItem_Bool(const char* label,
                                const char* shortcut,
                                bool selected,
                                bool enabled) {
  return ImGui::MenuItem(label, shortcut, selected, enabled);
}
CIMGUI_API bool igMenuItem_BoolPtr(const char* label,
                                   const char* shortcut,
                                   bool* p_selected,
                                   bool enabled) {
  return ImGui::MenuItem(label, shortcut, p_selected, enabled);
}
CIMGUI_API bool igBeginTooltip() {
  return ImGui::BeginTooltip();
}
CIMGUI_API void igEndTooltip() {
  return ImGui::EndTooltip();
}
CIMGUI_API void igSetTooltip(const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);
  ImGui::SetTooltipV(fmt, args);
  va_end(args);
}
CIMGUI_API void igSetTooltipV(const char* fmt, va_list args) {
  return ImGui::SetTooltipV(fmt, args);
}
CIMGUI_API bool igBeginItemTooltip() {
  return ImGui::BeginItemTooltip();
}
CIMGUI_API void igSetItemTooltip(const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);
  ImGui::SetItemTooltipV(fmt, args);
  va_end(args);
}
CIMGUI_API void igSetItemTooltipV(const char* fmt, va_list args) {
  return ImGui::SetItemTooltipV(fmt, args);
}
CIMGUI_API bool igBeginPopup(const char* str_id, ImGuiWindowFlags flags) {
  return ImGui::BeginPopup(str_id, flags);
}
CIMGUI_API bool igBeginPopupModal(const char* name,
                                  bool* p_open,
                                  ImGuiWindowFlags flags) {
  return ImGui::BeginPopupModal(name, p_open, flags);
}
CIMGUI_API void igEndPopup() {
  return ImGui::EndPopup();
}
CIMGUI_API void igOpenPopup_Str(const char* str_id,
                                ImGuiPopupFlags popup_flags) {
  return ImGui::OpenPopup(str_id, popup_flags);
}
CIMGUI_API void igOpenPopup_ID(ImGuiID id, ImGuiPopupFlags popup_flags) {
  return ImGui::OpenPopup(id, popup_flags);
}
CIMGUI_API void igOpenPopupOnItemClick(const char* str_id,
                                       ImGuiPopupFlags popup_flags) {
  return ImGui::OpenPopupOnItemClick(str_id, popup_flags);
}
CIMGUI_API void igCloseCurrentPopup() {
  return ImGui::CloseCurrentPopup();
}
CIMGUI_API bool igBeginPopupContextItem(const char* str_id,
                                        ImGuiPopupFlags popup_flags) {
  return ImGui::BeginPopupContextItem(str_id, popup_flags);
}
CIMGUI_API bool igBeginPopupContextWindow(const char* str_id,
                                          ImGuiPopupFlags popup_flags) {
  return ImGui::BeginPopupContextWindow(str_id, popup_flags);
}
CIMGUI_API bool igBeginPopupContextVoid(const char* str_id,
                                        ImGuiPopupFlags popup_flags) {
  return ImGui::BeginPopupContextVoid(str_id, popup_flags);
}
CIMGUI_API bool igIsPopupOpen_Str(const char* str_id, ImGuiPopupFlags flags) {
  return ImGui::IsPopupOpen(str_id, flags);
}
CIMGUI_API bool igBeginTable(const char* str_id,
                             int column,
                             ImGuiTableFlags flags,
                             const ImVec2 outer_size,
                             float inner_width) {
  return ImGui::BeginTable(str_id, column, flags, outer_size, inner_width);
}
CIMGUI_API void igEndTable() {
  return ImGui::EndTable();
}
CIMGUI_API void igTableNextRow(ImGuiTableRowFlags row_flags,
                               float min_row_height) {
  return ImGui::TableNextRow(row_flags, min_row_height);
}
CIMGUI_API bool igTableNextColumn() {
  return ImGui::TableNextColumn();
}
CIMGUI_API bool igTableSetColumnIndex(int column_n) {
  return ImGui::TableSetColumnIndex(column_n);
}
CIMGUI_API void igTableSetupColumn(const char* label,
                                   ImGuiTableColumnFlags flags,
                                   float init_width_or_weight,
                                   ImGuiID user_id) {
  return ImGui::TableSetupColumn(label, flags, init_width_or_weight, user_id);
}
CIMGUI_API void igTableSetupScrollFreeze(int cols, int rows) {
  return ImGui::TableSetupScrollFreeze(cols, rows);
}
CIMGUI_API void igTableHeader(const char* label) {
  return ImGui::TableHeader(label);
}
CIMGUI_API void igTableHeadersRow() {
  return ImGui::TableHeadersRow();
}
CIMGUI_API void igTableAngledHeadersRow() {
  return ImGui::TableAngledHeadersRow();
}
CIMGUI_API ImGuiTableSortSpecs* igTableGetSortSpecs() {
  return ImGui::TableGetSortSpecs();
}
CIMGUI_API int igTableGetColumnCount() {
  return ImGui::TableGetColumnCount();
}
CIMGUI_API int igTableGetColumnIndex() {
  return ImGui::TableGetColumnIndex();
}
CIMGUI_API int igTableGetRowIndex() {
  return ImGui::TableGetRowIndex();
}
CIMGUI_API const char* igTableGetColumnName_Int(int column_n) {
  return ImGui::TableGetColumnName(column_n);
}
CIMGUI_API ImGuiTableColumnFlags igTableGetColumnFlags(int column_n) {
  return ImGui::TableGetColumnFlags(column_n);
}
CIMGUI_API void igTableSetColumnEnabled(int column_n, bool v) {
  return ImGui::TableSetColumnEnabled(column_n, v);
}
CIMGUI_API void igTableSetBgColor(ImGuiTableBgTarget target,
                                  ImU32 color,
                                  int column_n) {
  return ImGui::TableSetBgColor(target, color, column_n);
}
CIMGUI_API void igColumns(int count, const char* id, bool border) {
  return ImGui::Columns(count, id, border);
}
CIMGUI_API void igNextColumn() {
  return ImGui::NextColumn();
}
CIMGUI_API int igGetColumnIndex() {
  return ImGui::GetColumnIndex();
}
CIMGUI_API float igGetColumnWidth(int column_index) {
  return ImGui::GetColumnWidth(column_index);
}
CIMGUI_API void igSetColumnWidth(int column_index, float width) {
  return ImGui::SetColumnWidth(column_index, width);
}
CIMGUI_API float igGetColumnOffset(int column_index) {
  return ImGui::GetColumnOffset(column_index);
}
CIMGUI_API void igSetColumnOffset(int column_index, float offset_x) {
  return ImGui::SetColumnOffset(column_index, offset_x);
}
CIMGUI_API int igGetColumnsCount() {
  return ImGui::GetColumnsCount();
}
CIMGUI_API bool igBeginTabBar(const char* str_id, ImGuiTabBarFlags flags) {
  return ImGui::BeginTabBar(str_id, flags);
}
CIMGUI_API void igEndTabBar() {
  return ImGui::EndTabBar();
}
CIMGUI_API bool igBeginTabItem(const char* label,
                               bool* p_open,
                               ImGuiTabItemFlags flags) {
  return ImGui::BeginTabItem(label, p_open, flags);
}
CIMGUI_API void igEndTabItem() {
  return ImGui::EndTabItem();
}
CIMGUI_API bool igTabItemButton(const char* label, ImGuiTabItemFlags flags) {
  return ImGui::TabItemButton(label, flags);
}
CIMGUI_API void igSetTabItemClosed(const char* tab_or_docked_window_label) {
  return ImGui::SetTabItemClosed(tab_or_docked_window_label);
}
CIMGUI_API ImGuiID igDockSpace(ImGuiID id,
                               const ImVec2 size,
                               ImGuiDockNodeFlags flags,
                               const ImGuiWindowClass* window_class) {
  return ImGui::DockSpace(id, size, flags, window_class);
}
CIMGUI_API ImGuiID
igDockSpaceOverViewport(const ImGuiViewport* viewport,
                        ImGuiDockNodeFlags flags,
                        const ImGuiWindowClass* window_class) {
  return ImGui::DockSpaceOverViewport(viewport, flags, window_class);
}
CIMGUI_API void igSetNextWindowDockID(ImGuiID dock_id, ImGuiCond cond) {
  return ImGui::SetNextWindowDockID(dock_id, cond);
}
CIMGUI_API void igSetNextWindowClass(const ImGuiWindowClass* window_class) {
  return ImGui::SetNextWindowClass(window_class);
}
CIMGUI_API ImGuiID igGetWindowDockID() {
  return ImGui::GetWindowDockID();
}
CIMGUI_API bool igIsWindowDocked() {
  return ImGui::IsWindowDocked();
}
CIMGUI_API void igLogToTTY(int auto_open_depth) {
  return ImGui::LogToTTY(auto_open_depth);
}
CIMGUI_API void igLogToFile(int auto_open_depth, const char* filename) {
  return ImGui::LogToFile(auto_open_depth, filename);
}
CIMGUI_API void igLogToClipboard(int auto_open_depth) {
  return ImGui::LogToClipboard(auto_open_depth);
}
CIMGUI_API void igLogFinish() {
  return ImGui::LogFinish();
}
CIMGUI_API void igLogButtons() {
  return ImGui::LogButtons();
}
CIMGUI_API void igLogTextV(const char* fmt, va_list args) {
  return ImGui::LogTextV(fmt, args);
}
CIMGUI_API bool igBeginDragDropSource(ImGuiDragDropFlags flags) {
  return ImGui::BeginDragDropSource(flags);
}
CIMGUI_API bool igSetDragDropPayload(const char* type,
                                     const void* data,
                                     size_t sz,
                                     ImGuiCond cond) {
  return ImGui::SetDragDropPayload(type, data, sz, cond);
}
CIMGUI_API void igEndDragDropSource() {
  return ImGui::EndDragDropSource();
}
CIMGUI_API bool igBeginDragDropTarget() {
  return ImGui::BeginDragDropTarget();
}
CIMGUI_API const ImGuiPayload* igAcceptDragDropPayload(
    const char* type,
    ImGuiDragDropFlags flags) {
  return ImGui::AcceptDragDropPayload(type, flags);
}
CIMGUI_API void igEndDragDropTarget() {
  return ImGui::EndDragDropTarget();
}
CIMGUI_API const ImGuiPayload* igGetDragDropPayload() {
  return ImGui::GetDragDropPayload();
}
CIMGUI_API void igBeginDisabled(bool disabled) {
  return ImGui::BeginDisabled(disabled);
}
CIMGUI_API void igEndDisabled() {
  return ImGui::EndDisabled();
}
CIMGUI_API void igPushClipRect(const ImVec2 clip_rect_min,
                               const ImVec2 clip_rect_max,
                               bool intersect_with_current_clip_rect) {
  return ImGui::PushClipRect(clip_rect_min, clip_rect_max,
                             intersect_with_current_clip_rect);
}
CIMGUI_API void igPopClipRect() {
  return ImGui::PopClipRect();
}
CIMGUI_API void igSetItemDefaultFocus() {
  return ImGui::SetItemDefaultFocus();
}
CIMGUI_API void igSetKeyboardFocusHere(int offset) {
  return ImGui::SetKeyboardFocusHere(offset);
}
CIMGUI_API void igSetNextItemAllowOverlap() {
  return ImGui::SetNextItemAllowOverlap();
}
CIMGUI_API bool igIsItemHovered(ImGuiHoveredFlags flags) {
  return ImGui::IsItemHovered(flags);
}
CIMGUI_API bool igIsItemActive() {
  return ImGui::IsItemActive();
}
CIMGUI_API bool igIsItemFocused() {
  return ImGui::IsItemFocused();
}
CIMGUI_API bool igIsItemClicked(ImGuiMouseButton mouse_button) {
  return ImGui::IsItemClicked(mouse_button);
}
CIMGUI_API bool igIsItemVisible() {
  return ImGui::IsItemVisible();
}
CIMGUI_API bool igIsItemEdited() {
  return ImGui::IsItemEdited();
}
CIMGUI_API bool igIsItemActivated() {
  return ImGui::IsItemActivated();
}
CIMGUI_API bool igIsItemDeactivated() {
  return ImGui::IsItemDeactivated();
}
CIMGUI_API bool igIsItemDeactivatedAfterEdit() {
  return ImGui::IsItemDeactivatedAfterEdit();
}
CIMGUI_API bool igIsItemToggledOpen() {
  return ImGui::IsItemToggledOpen();
}
CIMGUI_API bool igIsAnyItemHovered() {
  return ImGui::IsAnyItemHovered();
}
CIMGUI_API bool igIsAnyItemActive() {
  return ImGui::IsAnyItemActive();
}
CIMGUI_API bool igIsAnyItemFocused() {
  return ImGui::IsAnyItemFocused();
}
CIMGUI_API ImGuiID igGetItemID() {
  return ImGui::GetItemID();
}
CIMGUI_API void igGetItemRectMin(ImVec2* pOut) {
  *pOut = ImGui::GetItemRectMin();
}
CIMGUI_API void igGetItemRectMax(ImVec2* pOut) {
  *pOut = ImGui::GetItemRectMax();
}
CIMGUI_API void igGetItemRectSize(ImVec2* pOut) {
  *pOut = ImGui::GetItemRectSize();
}
CIMGUI_API ImGuiViewport* igGetMainViewport() {
  return ImGui::GetMainViewport();
}
CIMGUI_API ImDrawList* igGetBackgroundDrawList_Nil() {
  return ImGui::GetBackgroundDrawList();
}
CIMGUI_API ImDrawList* igGetForegroundDrawList_Nil() {
  return ImGui::GetForegroundDrawList();
}
CIMGUI_API ImDrawList* igGetBackgroundDrawList_ViewportPtr(
    ImGuiViewport* viewport) {
  return ImGui::GetBackgroundDrawList(viewport);
}
CIMGUI_API ImDrawList* igGetForegroundDrawList_ViewportPtr(
    ImGuiViewport* viewport) {
  return ImGui::GetForegroundDrawList(viewport);
}
CIMGUI_API bool igIsRectVisible_Nil(const ImVec2 size) {
  return ImGui::IsRectVisible(size);
}
CIMGUI_API bool igIsRectVisible_Vec2(const ImVec2 rect_min,
                                     const ImVec2 rect_max) {
  return ImGui::IsRectVisible(rect_min, rect_max);
}
CIMGUI_API double igGetTime() {
  return ImGui::GetTime();
}
CIMGUI_API int igGetFrameCount() {
  return ImGui::GetFrameCount();
}
CIMGUI_API ImDrawListSharedData* igGetDrawListSharedData() {
  return ImGui::GetDrawListSharedData();
}
CIMGUI_API const char* igGetStyleColorName(ImGuiCol idx) {
  return ImGui::GetStyleColorName(idx);
}
CIMGUI_API void igSetStateStorage(ImGuiStorage* storage) {
  return ImGui::SetStateStorage(storage);
}
CIMGUI_API ImGuiStorage* igGetStateStorage() {
  return ImGui::GetStateStorage();
}
CIMGUI_API void igCalcTextSize(ImVec2* pOut,
                               const char* text,
                               const char* text_end,
                               bool hide_text_after_double_hash,
                               float wrap_width) {
  *pOut = ImGui::CalcTextSize(text, text_end, hide_text_after_double_hash,
                              wrap_width);
}
CIMGUI_API void igColorConvertU32ToFloat4(ImVec4* pOut, ImU32 in) {
  *pOut = ImGui::ColorConvertU32ToFloat4(in);
}
CIMGUI_API ImU32 igColorConvertFloat4ToU32(const ImVec4 in) {
  return ImGui::ColorConvertFloat4ToU32(in);
}
CIMGUI_API void igColorConvertRGBtoHSV(float r,
                                       float g,
                                       float b,
                                       float* out_h,
                                       float* out_s,
                                       float* out_v) {
  return ImGui::ColorConvertRGBtoHSV(r, g, b, *out_h, *out_s, *out_v);
}
CIMGUI_API void igColorConvertHSVtoRGB(float h,
                                       float s,
                                       float v,
                                       float* out_r,
                                       float* out_g,
                                       float* out_b) {
  return ImGui::ColorConvertHSVtoRGB(h, s, v, *out_r, *out_g, *out_b);
}
CIMGUI_API bool igIsKeyDown_Nil(ImGuiKey key) {
  return ImGui::IsKeyDown(key);
}
CIMGUI_API bool igIsKeyPressed_Bool(ImGuiKey key, bool repeat) {
  return ImGui::IsKeyPressed(key, repeat);
}
CIMGUI_API bool igIsKeyReleased_Nil(ImGuiKey key) {
  return ImGui::IsKeyReleased(key);
}
CIMGUI_API bool igIsKeyChordPressed_Nil(ImGuiKeyChord key_chord) {
  return ImGui::IsKeyChordPressed(key_chord);
}
CIMGUI_API int igGetKeyPressedAmount(ImGuiKey key,
                                     float repeat_delay,
                                     float rate) {
  return ImGui::GetKeyPressedAmount(key, repeat_delay, rate);
}
CIMGUI_API const char* igGetKeyName(ImGuiKey key) {
  return ImGui::GetKeyName(key);
}
CIMGUI_API void igSetNextFrameWantCaptureKeyboard(bool want_capture_keyboard) {
  return ImGui::SetNextFrameWantCaptureKeyboard(want_capture_keyboard);
}
CIMGUI_API bool igIsMouseDown_Nil(ImGuiMouseButton button) {
  return ImGui::IsMouseDown(button);
}
CIMGUI_API bool igIsMouseClicked_Bool(ImGuiMouseButton button, bool repeat) {
  return ImGui::IsMouseClicked(button, repeat);
}
CIMGUI_API bool igIsMouseReleased_Nil(ImGuiMouseButton button) {
  return ImGui::IsMouseReleased(button);
}
CIMGUI_API bool igIsMouseDoubleClicked_Nil(ImGuiMouseButton button) {
  return ImGui::IsMouseDoubleClicked(button);
}
CIMGUI_API int igGetMouseClickedCount(ImGuiMouseButton button) {
  return ImGui::GetMouseClickedCount(button);
}
CIMGUI_API bool igIsMouseHoveringRect(const ImVec2 r_min,
                                      const ImVec2 r_max,
                                      bool clip) {
  return ImGui::IsMouseHoveringRect(r_min, r_max, clip);
}
CIMGUI_API bool igIsMousePosValid(const ImVec2* mouse_pos) {
  return ImGui::IsMousePosValid(mouse_pos);
}
CIMGUI_API bool igIsAnyMouseDown() {
  return ImGui::IsAnyMouseDown();
}
CIMGUI_API void igGetMousePos(ImVec2* pOut) {
  *pOut = ImGui::GetMousePos();
}
CIMGUI_API void igGetMousePosOnOpeningCurrentPopup(ImVec2* pOut) {
  *pOut = ImGui::GetMousePosOnOpeningCurrentPopup();
}
CIMGUI_API bool igIsMouseDragging(ImGuiMouseButton button,
                                  float lock_threshold) {
  return ImGui::IsMouseDragging(button, lock_threshold);
}
CIMGUI_API void igGetMouseDragDelta(ImVec2* pOut,
                                    ImGuiMouseButton button,
                                    float lock_threshold) {
  *pOut = ImGui::GetMouseDragDelta(button, lock_threshold);
}
CIMGUI_API void igResetMouseDragDelta(ImGuiMouseButton button) {
  return ImGui::ResetMouseDragDelta(button);
}
CIMGUI_API ImGuiMouseCursor igGetMouseCursor() {
  return ImGui::GetMouseCursor();
}
CIMGUI_API void igSetMouseCursor(ImGuiMouseCursor cursor_type) {
  return ImGui::SetMouseCursor(cursor_type);
}
CIMGUI_API void igSetNextFrameWantCaptureMouse(bool want_capture_mouse) {
  return ImGui::SetNextFrameWantCaptureMouse(want_capture_mouse);
}
CIMGUI_API const char* igGetClipboardText() {
  return ImGui::GetClipboardText();
}
CIMGUI_API void igSetClipboardText(const char* text) {
  return ImGui::SetClipboardText(text);
}
CIMGUI_API void igLoadIniSettingsFromDisk(const char* ini_filename) {
  return ImGui::LoadIniSettingsFromDisk(ini_filename);
}
CIMGUI_API void igLoadIniSettingsFromMemory(const char* ini_data,
                                            size_t ini_size) {
  return ImGui::LoadIniSettingsFromMemory(ini_data, ini_size);
}
CIMGUI_API void igSaveIniSettingsToDisk(const char* ini_filename) {
  return ImGui::SaveIniSettingsToDisk(ini_filename);
}
CIMGUI_API const char* igSaveIniSettingsToMemory(size_t* out_ini_size) {
  return ImGui::SaveIniSettingsToMemory(out_ini_size);
}
CIMGUI_API void igDebugTextEncoding(const char* text) {
  return ImGui::DebugTextEncoding(text);
}
CIMGUI_API void igDebugFlashStyleColor(ImGuiCol idx) {
  return ImGui::DebugFlashStyleColor(idx);
}
CIMGUI_API void igDebugStartItemPicker() {
  return ImGui::DebugStartItemPicker();
}
CIMGUI_API bool igDebugCheckVersionAndDataLayout(const char* version_str,
                                                 size_t sz_io,
                                                 size_t sz_style,
                                                 size_t sz_vec2,
                                                 size_t sz_vec4,
                                                 size_t sz_drawvert,
                                                 size_t sz_drawidx) {
  return ImGui::DebugCheckVersionAndDataLayout(
      version_str, sz_io, sz_style, sz_vec2, sz_vec4, sz_drawvert, sz_drawidx);
}
CIMGUI_API void igSetAllocatorFunctions(ImGuiMemAllocFunc alloc_func,
                                        ImGuiMemFreeFunc free_func,
                                        void* user_data) {
  return ImGui::SetAllocatorFunctions(alloc_func, free_func, user_data);
}
CIMGUI_API void igGetAllocatorFunctions(ImGuiMemAllocFunc* p_alloc_func,
                                        ImGuiMemFreeFunc* p_free_func,
                                        void** p_user_data) {
  return ImGui::GetAllocatorFunctions(p_alloc_func, p_free_func, p_user_data);
}
CIMGUI_API void* igMemAlloc(size_t size) {
  return ImGui::MemAlloc(size);
}
CIMGUI_API void igMemFree(void* ptr) {
  return ImGui::MemFree(ptr);
}
CIMGUI_API ImGuiPlatformIO* igGetPlatformIO() {
  return &ImGui::GetPlatformIO();
}
CIMGUI_API void igUpdatePlatformWindows() {
  return ImGui::UpdatePlatformWindows();
}
CIMGUI_API void igRenderPlatformWindowsDefault(void* platform_render_arg,
                                               void* renderer_render_arg) {
  return ImGui::RenderPlatformWindowsDefault(platform_render_arg,
                                             renderer_render_arg);
}
CIMGUI_API void igDestroyPlatformWindows() {
  return ImGui::DestroyPlatformWindows();
}
CIMGUI_API ImGuiViewport* igFindViewportByID(ImGuiID id) {
  return ImGui::FindViewportByID(id);
}
CIMGUI_API ImGuiViewport* igFindViewportByPlatformHandle(
    void* platform_handle) {
  return ImGui::FindViewportByPlatformHandle(platform_handle);
}
CIMGUI_API ImGuiTableSortSpecs* ImGuiTableSortSpecs_ImGuiTableSortSpecs(void) {
  return IM_NEW(ImGuiTableSortSpecs)();
}
CIMGUI_API void ImGuiTableSortSpecs_destroy(ImGuiTableSortSpecs* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiTableColumnSortSpecs*
ImGuiTableColumnSortSpecs_ImGuiTableColumnSortSpecs(void) {
  return IM_NEW(ImGuiTableColumnSortSpecs)();
}
CIMGUI_API void ImGuiTableColumnSortSpecs_destroy(
    ImGuiTableColumnSortSpecs* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiStyle* ImGuiStyle_ImGuiStyle(void) {
  return IM_NEW(ImGuiStyle)();
}
CIMGUI_API void ImGuiStyle_destroy(ImGuiStyle* self) {
  IM_DELETE(self);
}
CIMGUI_API void ImGuiStyle_ScaleAllSizes(ImGuiStyle* self, float scale_factor) {
  return self->ScaleAllSizes(scale_factor);
}
CIMGUI_API void ImGuiIO_AddKeyEvent(ImGuiIO* self, ImGuiKey key, bool down) {
  return self->AddKeyEvent(key, down);
}
CIMGUI_API void ImGuiIO_AddKeyAnalogEvent(ImGuiIO* self,
                                          ImGuiKey key,
                                          bool down,
                                          float v) {
  return self->AddKeyAnalogEvent(key, down, v);
}
CIMGUI_API void ImGuiIO_AddMousePosEvent(ImGuiIO* self, float x, float y) {
  return self->AddMousePosEvent(x, y);
}
CIMGUI_API void ImGuiIO_AddMouseButtonEvent(ImGuiIO* self,
                                            int button,
                                            bool down) {
  return self->AddMouseButtonEvent(button, down);
}
CIMGUI_API void ImGuiIO_AddMouseWheelEvent(ImGuiIO* self,
                                           float wheel_x,
                                           float wheel_y) {
  return self->AddMouseWheelEvent(wheel_x, wheel_y);
}
CIMGUI_API void ImGuiIO_AddMouseSourceEvent(ImGuiIO* self,
                                            ImGuiMouseSource source) {
  return self->AddMouseSourceEvent(source);
}
CIMGUI_API void ImGuiIO_AddMouseViewportEvent(ImGuiIO* self, ImGuiID id) {
  return self->AddMouseViewportEvent(id);
}
CIMGUI_API void ImGuiIO_AddFocusEvent(ImGuiIO* self, bool focused) {
  return self->AddFocusEvent(focused);
}
CIMGUI_API void ImGuiIO_AddInputCharacter(ImGuiIO* self, unsigned int c) {
  return self->AddInputCharacter(c);
}
CIMGUI_API void ImGuiIO_AddInputCharacterUTF16(ImGuiIO* self, ImWchar16 c) {
  return self->AddInputCharacterUTF16(c);
}
CIMGUI_API void ImGuiIO_AddInputCharactersUTF8(ImGuiIO* self, const char* str) {
  return self->AddInputCharactersUTF8(str);
}
CIMGUI_API void ImGuiIO_SetKeyEventNativeData(ImGuiIO* self,
                                              ImGuiKey key,
                                              int native_keycode,
                                              int native_scancode,
                                              int native_legacy_index) {
  return self->SetKeyEventNativeData(key, native_keycode, native_scancode,
                                     native_legacy_index);
}
CIMGUI_API void ImGuiIO_SetAppAcceptingEvents(ImGuiIO* self,
                                              bool accepting_events) {
  return self->SetAppAcceptingEvents(accepting_events);
}
CIMGUI_API void ImGuiIO_ClearEventsQueue(ImGuiIO* self) {
  return self->ClearEventsQueue();
}
CIMGUI_API void ImGuiIO_ClearInputKeys(ImGuiIO* self) {
  return self->ClearInputKeys();
}
CIMGUI_API ImGuiIO* ImGuiIO_ImGuiIO(void) {
  return IM_NEW(ImGuiIO)();
}
CIMGUI_API void ImGuiIO_destroy(ImGuiIO* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiInputTextCallbackData*
ImGuiInputTextCallbackData_ImGuiInputTextCallbackData(void) {
  return IM_NEW(ImGuiInputTextCallbackData)();
}
CIMGUI_API void ImGuiInputTextCallbackData_destroy(
    ImGuiInputTextCallbackData* self) {
  IM_DELETE(self);
}
CIMGUI_API void ImGuiInputTextCallbackData_DeleteChars(
    ImGuiInputTextCallbackData* self,
    int pos,
    int bytes_count) {
  return self->DeleteChars(pos, bytes_count);
}
CIMGUI_API void ImGuiInputTextCallbackData_InsertChars(
    ImGuiInputTextCallbackData* self,
    int pos,
    const char* text,
    const char* text_end) {
  return self->InsertChars(pos, text, text_end);
}
CIMGUI_API void ImGuiInputTextCallbackData_SelectAll(
    ImGuiInputTextCallbackData* self) {
  return self->SelectAll();
}
CIMGUI_API void ImGuiInputTextCallbackData_ClearSelection(
    ImGuiInputTextCallbackData* self) {
  return self->ClearSelection();
}
CIMGUI_API bool ImGuiInputTextCallbackData_HasSelection(
    ImGuiInputTextCallbackData* self) {
  return self->HasSelection();
}
CIMGUI_API ImGuiWindowClass* ImGuiWindowClass_ImGuiWindowClass(void) {
  return IM_NEW(ImGuiWindowClass)();
}
CIMGUI_API void ImGuiWindowClass_destroy(ImGuiWindowClass* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiPayload* ImGuiPayload_ImGuiPayload(void) {
  return IM_NEW(ImGuiPayload)();
}
CIMGUI_API void ImGuiPayload_destroy(ImGuiPayload* self) {
  IM_DELETE(self);
}
CIMGUI_API void ImGuiPayload_Clear(ImGuiPayload* self) {
  return self->Clear();
}
CIMGUI_API bool ImGuiPayload_IsDataType(ImGuiPayload* self, const char* type) {
  return self->IsDataType(type);
}
CIMGUI_API bool ImGuiPayload_IsPreview(ImGuiPayload* self) {
  return self->IsPreview();
}
CIMGUI_API bool ImGuiPayload_IsDelivery(ImGuiPayload* self) {
  return self->IsDelivery();
}
CIMGUI_API ImGuiOnceUponAFrame* ImGuiOnceUponAFrame_ImGuiOnceUponAFrame(void) {
  return IM_NEW(ImGuiOnceUponAFrame)();
}
CIMGUI_API void ImGuiOnceUponAFrame_destroy(ImGuiOnceUponAFrame* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiTextFilter* ImGuiTextFilter_ImGuiTextFilter(
    const char* default_filter) {
  return IM_NEW(ImGuiTextFilter)(default_filter);
}
CIMGUI_API void ImGuiTextFilter_destroy(ImGuiTextFilter* self) {
  IM_DELETE(self);
}
CIMGUI_API bool ImGuiTextFilter_Draw(ImGuiTextFilter* self,
                                     const char* label,
                                     float width) {
  return self->Draw(label, width);
}
CIMGUI_API bool ImGuiTextFilter_PassFilter(ImGuiTextFilter* self,
                                           const char* text,
                                           const char* text_end) {
  return self->PassFilter(text, text_end);
}
CIMGUI_API void ImGuiTextFilter_Build(ImGuiTextFilter* self) {
  return self->Build();
}
CIMGUI_API void ImGuiTextFilter_Clear(ImGuiTextFilter* self) {
  return self->Clear();
}
CIMGUI_API bool ImGuiTextFilter_IsActive(ImGuiTextFilter* self) {
  return self->IsActive();
}
CIMGUI_API ImGuiTextRange* ImGuiTextRange_ImGuiTextRange_Nil(void) {
  return IM_NEW(ImGuiTextRange)();
}
CIMGUI_API void ImGuiTextRange_destroy(ImGuiTextRange* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiTextRange* ImGuiTextRange_ImGuiTextRange_Str(const char* _b,
                                                             const char* _e) {
  return IM_NEW(ImGuiTextRange)(_b, _e);
}
CIMGUI_API bool ImGuiTextRange_empty(ImGuiTextRange* self) {
  return self->empty();
}
CIMGUI_API void ImGuiTextRange_split(ImGuiTextRange* self,
                                     char separator,
                                     ImVector_ImGuiTextRange* out) {
  return self->split(separator, out);
}
CIMGUI_API ImGuiTextBuffer* ImGuiTextBuffer_ImGuiTextBuffer(void) {
  return IM_NEW(ImGuiTextBuffer)();
}
CIMGUI_API void ImGuiTextBuffer_destroy(ImGuiTextBuffer* self) {
  IM_DELETE(self);
}
CIMGUI_API const char* ImGuiTextBuffer_begin(ImGuiTextBuffer* self) {
  return self->begin();
}
CIMGUI_API const char* ImGuiTextBuffer_end(ImGuiTextBuffer* self) {
  return self->end();
}
CIMGUI_API int ImGuiTextBuffer_size(ImGuiTextBuffer* self) {
  return self->size();
}
CIMGUI_API bool ImGuiTextBuffer_empty(ImGuiTextBuffer* self) {
  return self->empty();
}
CIMGUI_API void ImGuiTextBuffer_clear(ImGuiTextBuffer* self) {
  return self->clear();
}
CIMGUI_API void ImGuiTextBuffer_reserve(ImGuiTextBuffer* self, int capacity) {
  return self->reserve(capacity);
}
CIMGUI_API const char* ImGuiTextBuffer_c_str(ImGuiTextBuffer* self) {
  return self->c_str();
}
CIMGUI_API void ImGuiTextBuffer_append(ImGuiTextBuffer* self,
                                       const char* str,
                                       const char* str_end) {
  return self->append(str, str_end);
}
CIMGUI_API void ImGuiTextBuffer_appendfv(ImGuiTextBuffer* self,
                                         const char* fmt,
                                         va_list args) {
  return self->appendfv(fmt, args);
}
CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePair_Int(ImGuiID _key,
                                                                   int _val) {
  return IM_NEW(ImGuiStoragePair)(_key, _val);
}
CIMGUI_API void ImGuiStoragePair_destroy(ImGuiStoragePair* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePair_Float(
    ImGuiID _key,
    float _val) {
  return IM_NEW(ImGuiStoragePair)(_key, _val);
}
CIMGUI_API ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePair_Ptr(ImGuiID _key,
                                                                   void* _val) {
  return IM_NEW(ImGuiStoragePair)(_key, _val);
}
CIMGUI_API void ImGuiStorage_Clear(ImGuiStorage* self) {
  return self->Clear();
}
CIMGUI_API int ImGuiStorage_GetInt(ImGuiStorage* self,
                                   ImGuiID key,
                                   int default_val) {
  return self->GetInt(key, default_val);
}
CIMGUI_API void ImGuiStorage_SetInt(ImGuiStorage* self, ImGuiID key, int val) {
  return self->SetInt(key, val);
}
CIMGUI_API bool ImGuiStorage_GetBool(ImGuiStorage* self,
                                     ImGuiID key,
                                     bool default_val) {
  return self->GetBool(key, default_val);
}
CIMGUI_API void ImGuiStorage_SetBool(ImGuiStorage* self,
                                     ImGuiID key,
                                     bool val) {
  return self->SetBool(key, val);
}
CIMGUI_API float ImGuiStorage_GetFloat(ImGuiStorage* self,
                                       ImGuiID key,
                                       float default_val) {
  return self->GetFloat(key, default_val);
}
CIMGUI_API void ImGuiStorage_SetFloat(ImGuiStorage* self,
                                      ImGuiID key,
                                      float val) {
  return self->SetFloat(key, val);
}
CIMGUI_API void* ImGuiStorage_GetVoidPtr(ImGuiStorage* self, ImGuiID key) {
  return self->GetVoidPtr(key);
}
CIMGUI_API void ImGuiStorage_SetVoidPtr(ImGuiStorage* self,
                                        ImGuiID key,
                                        void* val) {
  return self->SetVoidPtr(key, val);
}
CIMGUI_API int* ImGuiStorage_GetIntRef(ImGuiStorage* self,
                                       ImGuiID key,
                                       int default_val) {
  return self->GetIntRef(key, default_val);
}
CIMGUI_API bool* ImGuiStorage_GetBoolRef(ImGuiStorage* self,
                                         ImGuiID key,
                                         bool default_val) {
  return self->GetBoolRef(key, default_val);
}
CIMGUI_API float* ImGuiStorage_GetFloatRef(ImGuiStorage* self,
                                           ImGuiID key,
                                           float default_val) {
  return self->GetFloatRef(key, default_val);
}
CIMGUI_API void** ImGuiStorage_GetVoidPtrRef(ImGuiStorage* self,
                                             ImGuiID key,
                                             void* default_val) {
  return self->GetVoidPtrRef(key, default_val);
}
CIMGUI_API void ImGuiStorage_BuildSortByKey(ImGuiStorage* self) {
  return self->BuildSortByKey();
}
CIMGUI_API void ImGuiStorage_SetAllInt(ImGuiStorage* self, int val) {
  return self->SetAllInt(val);
}
CIMGUI_API ImGuiListClipper* ImGuiListClipper_ImGuiListClipper(void) {
  return IM_NEW(ImGuiListClipper)();
}
CIMGUI_API void ImGuiListClipper_destroy(ImGuiListClipper* self) {
  IM_DELETE(self);
}
CIMGUI_API void ImGuiListClipper_Begin(ImGuiListClipper* self,
                                       int items_count,
                                       float items_height) {
  return self->Begin(items_count, items_height);
}
CIMGUI_API void ImGuiListClipper_End(ImGuiListClipper* self) {
  return self->End();
}
CIMGUI_API bool ImGuiListClipper_Step(ImGuiListClipper* self) {
  return self->Step();
}
CIMGUI_API void ImGuiListClipper_IncludeItemByIndex(ImGuiListClipper* self,
                                                    int item_index) {
  return self->IncludeItemByIndex(item_index);
}
CIMGUI_API void ImGuiListClipper_IncludeItemsByIndex(ImGuiListClipper* self,
                                                     int item_begin,
                                                     int item_end) {
  return self->IncludeItemsByIndex(item_begin, item_end);
}
CIMGUI_API ImColor* ImColor_ImColor_Nil(void) {
  return IM_NEW(ImColor)();
}
CIMGUI_API void ImColor_destroy(ImColor* self) {
  IM_DELETE(self);
}
CIMGUI_API ImColor* ImColor_ImColor_Float(float r, float g, float b, float a) {
  return IM_NEW(ImColor)(r, g, b, a);
}
CIMGUI_API ImColor* ImColor_ImColor_Vec4(const ImVec4 col) {
  return IM_NEW(ImColor)(col);
}
CIMGUI_API ImColor* ImColor_ImColor_Int(int r, int g, int b, int a) {
  return IM_NEW(ImColor)(r, g, b, a);
}
CIMGUI_API ImColor* ImColor_ImColor_U32(ImU32 rgba) {
  return IM_NEW(ImColor)(rgba);
}
CIMGUI_API void ImColor_SetHSV(ImColor* self,
                               float h,
                               float s,
                               float v,
                               float a) {
  return self->SetHSV(h, s, v, a);
}
CIMGUI_API void ImColor_HSV(ImColor* pOut, float h, float s, float v, float a) {
  *pOut = ImColor::HSV(h, s, v, a);
}
CIMGUI_API ImDrawCmd* ImDrawCmd_ImDrawCmd(void) {
  return IM_NEW(ImDrawCmd)();
}
CIMGUI_API void ImDrawCmd_destroy(ImDrawCmd* self) {
  IM_DELETE(self);
}
CIMGUI_API ImTextureID ImDrawCmd_GetTexID(ImDrawCmd* self) {
  return self->GetTexID();
}
CIMGUI_API ImDrawListSplitter* ImDrawListSplitter_ImDrawListSplitter(void) {
  return IM_NEW(ImDrawListSplitter)();
}
CIMGUI_API void ImDrawListSplitter_destroy(ImDrawListSplitter* self) {
  IM_DELETE(self);
}
CIMGUI_API void ImDrawListSplitter_Clear(ImDrawListSplitter* self) {
  return self->Clear();
}
CIMGUI_API void ImDrawListSplitter_ClearFreeMemory(ImDrawListSplitter* self) {
  return self->ClearFreeMemory();
}
CIMGUI_API void ImDrawListSplitter_Split(ImDrawListSplitter* self,
                                         ImDrawList* draw_list,
                                         int count) {
  return self->Split(draw_list, count);
}
CIMGUI_API void ImDrawListSplitter_Merge(ImDrawListSplitter* self,
                                         ImDrawList* draw_list) {
  return self->Merge(draw_list);
}
CIMGUI_API void ImDrawListSplitter_SetCurrentChannel(ImDrawListSplitter* self,
                                                     ImDrawList* draw_list,
                                                     int channel_idx) {
  return self->SetCurrentChannel(draw_list, channel_idx);
}
CIMGUI_API ImDrawList* ImDrawList_ImDrawList(
    ImDrawListSharedData* shared_data) {
  return IM_NEW(ImDrawList)(shared_data);
}
CIMGUI_API void ImDrawList_destroy(ImDrawList* self) {
  IM_DELETE(self);
}
CIMGUI_API void ImDrawList_PushClipRect(ImDrawList* self,
                                        const ImVec2 clip_rect_min,
                                        const ImVec2 clip_rect_max,
                                        bool intersect_with_current_clip_rect) {
  return self->PushClipRect(clip_rect_min, clip_rect_max,
                            intersect_with_current_clip_rect);
}
CIMGUI_API void ImDrawList_PushClipRectFullScreen(ImDrawList* self) {
  return self->PushClipRectFullScreen();
}
CIMGUI_API void ImDrawList_PopClipRect(ImDrawList* self) {
  return self->PopClipRect();
}
CIMGUI_API void ImDrawList_PushTextureID(ImDrawList* self,
                                         ImTextureID texture_id) {
  return self->PushTextureID(texture_id);
}
CIMGUI_API void ImDrawList_PopTextureID(ImDrawList* self) {
  return self->PopTextureID();
}
CIMGUI_API void ImDrawList_GetClipRectMin(ImVec2* pOut, ImDrawList* self) {
  *pOut = self->GetClipRectMin();
}
CIMGUI_API void ImDrawList_GetClipRectMax(ImVec2* pOut, ImDrawList* self) {
  *pOut = self->GetClipRectMax();
}
CIMGUI_API void ImDrawList_AddLine(ImDrawList* self,
                                   const ImVec2 p1,
                                   const ImVec2 p2,
                                   ImU32 col,
                                   float thickness) {
  return self->AddLine(p1, p2, col, thickness);
}
CIMGUI_API void ImDrawList_AddRect(ImDrawList* self,
                                   const ImVec2 p_min,
                                   const ImVec2 p_max,
                                   ImU32 col,
                                   float rounding,
                                   ImDrawFlags flags,
                                   float thickness) {
  return self->AddRect(p_min, p_max, col, rounding, flags, thickness);
}
CIMGUI_API void ImDrawList_AddRectFilled(ImDrawList* self,
                                         const ImVec2 p_min,
                                         const ImVec2 p_max,
                                         ImU32 col,
                                         float rounding,
                                         ImDrawFlags flags) {
  return self->AddRectFilled(p_min, p_max, col, rounding, flags);
}
CIMGUI_API void ImDrawList_AddRectFilledMultiColor(ImDrawList* self,
                                                   const ImVec2 p_min,
                                                   const ImVec2 p_max,
                                                   ImU32 col_upr_left,
                                                   ImU32 col_upr_right,
                                                   ImU32 col_bot_right,
                                                   ImU32 col_bot_left) {
  return self->AddRectFilledMultiColor(
      p_min, p_max, col_upr_left, col_upr_right, col_bot_right, col_bot_left);
}
CIMGUI_API void ImDrawList_AddQuad(ImDrawList* self,
                                   const ImVec2 p1,
                                   const ImVec2 p2,
                                   const ImVec2 p3,
                                   const ImVec2 p4,
                                   ImU32 col,
                                   float thickness) {
  return self->AddQuad(p1, p2, p3, p4, col, thickness);
}
CIMGUI_API void ImDrawList_AddQuadFilled(ImDrawList* self,
                                         const ImVec2 p1,
                                         const ImVec2 p2,
                                         const ImVec2 p3,
                                         const ImVec2 p4,
                                         ImU32 col) {
  return self->AddQuadFilled(p1, p2, p3, p4, col);
}
CIMGUI_API void ImDrawList_AddTriangle(ImDrawList* self,
                                       const ImVec2 p1,
                                       const ImVec2 p2,
                                       const ImVec2 p3,
                                       ImU32 col,
                                       float thickness) {
  return self->AddTriangle(p1, p2, p3, col, thickness);
}
CIMGUI_API void ImDrawList_AddTriangleFilled(ImDrawList* self,
                                             const ImVec2 p1,
                                             const ImVec2 p2,
                                             const ImVec2 p3,
                                             ImU32 col) {
  return self->AddTriangleFilled(p1, p2, p3, col);
}
CIMGUI_API void ImDrawList_AddCircle(ImDrawList* self,
                                     const ImVec2 center,
                                     float radius,
                                     ImU32 col,
                                     int num_segments,
                                     float thickness) {
  return self->AddCircle(center, radius, col, num_segments, thickness);
}
CIMGUI_API void ImDrawList_AddCircleFilled(ImDrawList* self,
                                           const ImVec2 center,
                                           float radius,
                                           ImU32 col,
                                           int num_segments) {
  return self->AddCircleFilled(center, radius, col, num_segments);
}
CIMGUI_API void ImDrawList_AddNgon(ImDrawList* self,
                                   const ImVec2 center,
                                   float radius,
                                   ImU32 col,
                                   int num_segments,
                                   float thickness) {
  return self->AddNgon(center, radius, col, num_segments, thickness);
}
CIMGUI_API void ImDrawList_AddNgonFilled(ImDrawList* self,
                                         const ImVec2 center,
                                         float radius,
                                         ImU32 col,
                                         int num_segments) {
  return self->AddNgonFilled(center, radius, col, num_segments);
}
CIMGUI_API void ImDrawList_AddEllipse(ImDrawList* self,
                                      const ImVec2 center,
                                      const ImVec2 radius,
                                      ImU32 col,
                                      float rot,
                                      int num_segments,
                                      float thickness) {
  return self->AddEllipse(center, radius, col, rot, num_segments, thickness);
}
CIMGUI_API void ImDrawList_AddEllipseFilled(ImDrawList* self,
                                            const ImVec2 center,
                                            const ImVec2 radius,
                                            ImU32 col,
                                            float rot,
                                            int num_segments) {
  return self->AddEllipseFilled(center, radius, col, rot, num_segments);
}
CIMGUI_API void ImDrawList_AddText_Vec2(ImDrawList* self,
                                        const ImVec2 pos,
                                        ImU32 col,
                                        const char* text_begin,
                                        const char* text_end) {
  return self->AddText(pos, col, text_begin, text_end);
}
CIMGUI_API void ImDrawList_AddText_FontPtr(ImDrawList* self,
                                           const ImFont* font,
                                           float font_size,
                                           const ImVec2 pos,
                                           ImU32 col,
                                           const char* text_begin,
                                           const char* text_end,
                                           float wrap_width,
                                           const ImVec4* cpu_fine_clip_rect) {
  return self->AddText(font, font_size, pos, col, text_begin, text_end,
                       wrap_width, cpu_fine_clip_rect);
}
CIMGUI_API void ImDrawList_AddBezierCubic(ImDrawList* self,
                                          const ImVec2 p1,
                                          const ImVec2 p2,
                                          const ImVec2 p3,
                                          const ImVec2 p4,
                                          ImU32 col,
                                          float thickness,
                                          int num_segments) {
  return self->AddBezierCubic(p1, p2, p3, p4, col, thickness, num_segments);
}
CIMGUI_API void ImDrawList_AddBezierQuadratic(ImDrawList* self,
                                              const ImVec2 p1,
                                              const ImVec2 p2,
                                              const ImVec2 p3,
                                              ImU32 col,
                                              float thickness,
                                              int num_segments) {
  return self->AddBezierQuadratic(p1, p2, p3, col, thickness, num_segments);
}
CIMGUI_API void ImDrawList_AddPolyline(ImDrawList* self,
                                       const ImVec2* points,
                                       int num_points,
                                       ImU32 col,
                                       ImDrawFlags flags,
                                       float thickness) {
  return self->AddPolyline(points, num_points, col, flags, thickness);
}
CIMGUI_API void ImDrawList_AddConvexPolyFilled(ImDrawList* self,
                                               const ImVec2* points,
                                               int num_points,
                                               ImU32 col) {
  return self->AddConvexPolyFilled(points, num_points, col);
}
CIMGUI_API void ImDrawList_AddConcavePolyFilled(ImDrawList* self,
                                                const ImVec2* points,
                                                int num_points,
                                                ImU32 col) {
  return self->AddConcavePolyFilled(points, num_points, col);
}
CIMGUI_API void ImDrawList_AddImage(ImDrawList* self,
                                    ImTextureID user_texture_id,
                                    const ImVec2 p_min,
                                    const ImVec2 p_max,
                                    const ImVec2 uv_min,
                                    const ImVec2 uv_max,
                                    ImU32 col) {
  return self->AddImage(user_texture_id, p_min, p_max, uv_min, uv_max, col);
}
CIMGUI_API void ImDrawList_AddImageQuad(ImDrawList* self,
                                        ImTextureID user_texture_id,
                                        const ImVec2 p1,
                                        const ImVec2 p2,
                                        const ImVec2 p3,
                                        const ImVec2 p4,
                                        const ImVec2 uv1,
                                        const ImVec2 uv2,
                                        const ImVec2 uv3,
                                        const ImVec2 uv4,
                                        ImU32 col) {
  return self->AddImageQuad(user_texture_id, p1, p2, p3, p4, uv1, uv2, uv3, uv4,
                            col);
}
CIMGUI_API void ImDrawList_AddImageRounded(ImDrawList* self,
                                           ImTextureID user_texture_id,
                                           const ImVec2 p_min,
                                           const ImVec2 p_max,
                                           const ImVec2 uv_min,
                                           const ImVec2 uv_max,
                                           ImU32 col,
                                           float rounding,
                                           ImDrawFlags flags) {
  return self->AddImageRounded(user_texture_id, p_min, p_max, uv_min, uv_max,
                               col, rounding, flags);
}
CIMGUI_API void ImDrawList_PathClear(ImDrawList* self) {
  return self->PathClear();
}
CIMGUI_API void ImDrawList_PathLineTo(ImDrawList* self, const ImVec2 pos) {
  return self->PathLineTo(pos);
}
CIMGUI_API void ImDrawList_PathLineToMergeDuplicate(ImDrawList* self,
                                                    const ImVec2 pos) {
  return self->PathLineToMergeDuplicate(pos);
}
CIMGUI_API void ImDrawList_PathFillConvex(ImDrawList* self, ImU32 col) {
  return self->PathFillConvex(col);
}
CIMGUI_API void ImDrawList_PathFillConcave(ImDrawList* self, ImU32 col) {
  return self->PathFillConcave(col);
}
CIMGUI_API void ImDrawList_PathStroke(ImDrawList* self,
                                      ImU32 col,
                                      ImDrawFlags flags,
                                      float thickness) {
  return self->PathStroke(col, flags, thickness);
}
CIMGUI_API void ImDrawList_PathArcTo(ImDrawList* self,
                                     const ImVec2 center,
                                     float radius,
                                     float a_min,
                                     float a_max,
                                     int num_segments) {
  return self->PathArcTo(center, radius, a_min, a_max, num_segments);
}
CIMGUI_API void ImDrawList_PathArcToFast(ImDrawList* self,
                                         const ImVec2 center,
                                         float radius,
                                         int a_min_of_12,
                                         int a_max_of_12) {
  return self->PathArcToFast(center, radius, a_min_of_12, a_max_of_12);
}
CIMGUI_API void ImDrawList_PathEllipticalArcTo(ImDrawList* self,
                                               const ImVec2 center,
                                               const ImVec2 radius,
                                               float rot,
                                               float a_min,
                                               float a_max,
                                               int num_segments) {
  return self->PathEllipticalArcTo(center, radius, rot, a_min, a_max,
                                   num_segments);
}
CIMGUI_API void ImDrawList_PathBezierCubicCurveTo(ImDrawList* self,
                                                  const ImVec2 p2,
                                                  const ImVec2 p3,
                                                  const ImVec2 p4,
                                                  int num_segments) {
  return self->PathBezierCubicCurveTo(p2, p3, p4, num_segments);
}
CIMGUI_API void ImDrawList_PathBezierQuadraticCurveTo(ImDrawList* self,
                                                      const ImVec2 p2,
                                                      const ImVec2 p3,
                                                      int num_segments) {
  return self->PathBezierQuadraticCurveTo(p2, p3, num_segments);
}
CIMGUI_API void ImDrawList_PathRect(ImDrawList* self,
                                    const ImVec2 rect_min,
                                    const ImVec2 rect_max,
                                    float rounding,
                                    ImDrawFlags flags) {
  return self->PathRect(rect_min, rect_max, rounding, flags);
}
CIMGUI_API void ImDrawList_AddCallback(ImDrawList* self,
                                       ImDrawCallback callback,
                                       void* callback_data) {
  return self->AddCallback(callback, callback_data);
}
CIMGUI_API void ImDrawList_AddDrawCmd(ImDrawList* self) {
  return self->AddDrawCmd();
}
CIMGUI_API ImDrawList* ImDrawList_CloneOutput(ImDrawList* self) {
  return self->CloneOutput();
}
CIMGUI_API void ImDrawList_ChannelsSplit(ImDrawList* self, int count) {
  return self->ChannelsSplit(count);
}
CIMGUI_API void ImDrawList_ChannelsMerge(ImDrawList* self) {
  return self->ChannelsMerge();
}
CIMGUI_API void ImDrawList_ChannelsSetCurrent(ImDrawList* self, int n) {
  return self->ChannelsSetCurrent(n);
}
CIMGUI_API void ImDrawList_PrimReserve(ImDrawList* self,
                                       int idx_count,
                                       int vtx_count) {
  return self->PrimReserve(idx_count, vtx_count);
}
CIMGUI_API void ImDrawList_PrimUnreserve(ImDrawList* self,
                                         int idx_count,
                                         int vtx_count) {
  return self->PrimUnreserve(idx_count, vtx_count);
}
CIMGUI_API void ImDrawList_PrimRect(ImDrawList* self,
                                    const ImVec2 a,
                                    const ImVec2 b,
                                    ImU32 col) {
  return self->PrimRect(a, b, col);
}
CIMGUI_API void ImDrawList_PrimRectUV(ImDrawList* self,
                                      const ImVec2 a,
                                      const ImVec2 b,
                                      const ImVec2 uv_a,
                                      const ImVec2 uv_b,
                                      ImU32 col) {
  return self->PrimRectUV(a, b, uv_a, uv_b, col);
}
CIMGUI_API void ImDrawList_PrimQuadUV(ImDrawList* self,
                                      const ImVec2 a,
                                      const ImVec2 b,
                                      const ImVec2 c,
                                      const ImVec2 d,
                                      const ImVec2 uv_a,
                                      const ImVec2 uv_b,
                                      const ImVec2 uv_c,
                                      const ImVec2 uv_d,
                                      ImU32 col) {
  return self->PrimQuadUV(a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
}
CIMGUI_API void ImDrawList_PrimWriteVtx(ImDrawList* self,
                                        const ImVec2 pos,
                                        const ImVec2 uv,
                                        ImU32 col) {
  return self->PrimWriteVtx(pos, uv, col);
}
CIMGUI_API void ImDrawList_PrimWriteIdx(ImDrawList* self, ImDrawIdx idx) {
  return self->PrimWriteIdx(idx);
}
CIMGUI_API void ImDrawList_PrimVtx(ImDrawList* self,
                                   const ImVec2 pos,
                                   const ImVec2 uv,
                                   ImU32 col) {
  return self->PrimVtx(pos, uv, col);
}
CIMGUI_API void ImDrawList__ResetForNewFrame(ImDrawList* self) {
  return self->_ResetForNewFrame();
}
CIMGUI_API void ImDrawList__ClearFreeMemory(ImDrawList* self) {
  return self->_ClearFreeMemory();
}
CIMGUI_API void ImDrawList__PopUnusedDrawCmd(ImDrawList* self) {
  return self->_PopUnusedDrawCmd();
}
CIMGUI_API void ImDrawList__TryMergeDrawCmds(ImDrawList* self) {
  return self->_TryMergeDrawCmds();
}
CIMGUI_API void ImDrawList__OnChangedClipRect(ImDrawList* self) {
  return self->_OnChangedClipRect();
}
CIMGUI_API void ImDrawList__OnChangedTextureID(ImDrawList* self) {
  return self->_OnChangedTextureID();
}
CIMGUI_API void ImDrawList__OnChangedVtxOffset(ImDrawList* self) {
  return self->_OnChangedVtxOffset();
}
CIMGUI_API int ImDrawList__CalcCircleAutoSegmentCount(ImDrawList* self,
                                                      float radius) {
  return self->_CalcCircleAutoSegmentCount(radius);
}
CIMGUI_API void ImDrawList__PathArcToFastEx(ImDrawList* self,
                                            const ImVec2 center,
                                            float radius,
                                            int a_min_sample,
                                            int a_max_sample,
                                            int a_step) {
  return self->_PathArcToFastEx(center, radius, a_min_sample, a_max_sample,
                                a_step);
}
CIMGUI_API void ImDrawList__PathArcToN(ImDrawList* self,
                                       const ImVec2 center,
                                       float radius,
                                       float a_min,
                                       float a_max,
                                       int num_segments) {
  return self->_PathArcToN(center, radius, a_min, a_max, num_segments);
}
CIMGUI_API ImDrawData* ImDrawData_ImDrawData(void) {
  return IM_NEW(ImDrawData)();
}
CIMGUI_API void ImDrawData_destroy(ImDrawData* self) {
  IM_DELETE(self);
}
CIMGUI_API void ImDrawData_Clear(ImDrawData* self) {
  return self->Clear();
}
CIMGUI_API void ImDrawData_AddDrawList(ImDrawData* self,
                                       ImDrawList* draw_list) {
  return self->AddDrawList(draw_list);
}
CIMGUI_API void ImDrawData_DeIndexAllBuffers(ImDrawData* self) {
  return self->DeIndexAllBuffers();
}
CIMGUI_API void ImDrawData_ScaleClipRects(ImDrawData* self,
                                          const ImVec2 fb_scale) {
  return self->ScaleClipRects(fb_scale);
}
CIMGUI_API ImFontConfig* ImFontConfig_ImFontConfig(void) {
  return IM_NEW(ImFontConfig)();
}
CIMGUI_API void ImFontConfig_destroy(ImFontConfig* self) {
  IM_DELETE(self);
}
CIMGUI_API ImFontGlyphRangesBuilder*
ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder(void) {
  return IM_NEW(ImFontGlyphRangesBuilder)();
}
CIMGUI_API void ImFontGlyphRangesBuilder_destroy(
    ImFontGlyphRangesBuilder* self) {
  IM_DELETE(self);
}
CIMGUI_API void ImFontGlyphRangesBuilder_Clear(ImFontGlyphRangesBuilder* self) {
  return self->Clear();
}
CIMGUI_API bool ImFontGlyphRangesBuilder_GetBit(ImFontGlyphRangesBuilder* self,
                                                size_t n) {
  return self->GetBit(n);
}
CIMGUI_API void ImFontGlyphRangesBuilder_SetBit(ImFontGlyphRangesBuilder* self,
                                                size_t n) {
  return self->SetBit(n);
}
CIMGUI_API void ImFontGlyphRangesBuilder_AddChar(ImFontGlyphRangesBuilder* self,
                                                 ImWchar c) {
  return self->AddChar(c);
}
CIMGUI_API void ImFontGlyphRangesBuilder_AddText(ImFontGlyphRangesBuilder* self,
                                                 const char* text,
                                                 const char* text_end) {
  return self->AddText(text, text_end);
}
CIMGUI_API void ImFontGlyphRangesBuilder_AddRanges(
    ImFontGlyphRangesBuilder* self,
    const ImWchar* ranges) {
  return self->AddRanges(ranges);
}
CIMGUI_API void ImFontGlyphRangesBuilder_BuildRanges(
    ImFontGlyphRangesBuilder* self,
    ImVector_ImWchar* out_ranges) {
  return self->BuildRanges(out_ranges);
}
CIMGUI_API ImFontAtlasCustomRect* ImFontAtlasCustomRect_ImFontAtlasCustomRect(
    void) {
  return IM_NEW(ImFontAtlasCustomRect)();
}
CIMGUI_API void ImFontAtlasCustomRect_destroy(ImFontAtlasCustomRect* self) {
  IM_DELETE(self);
}
CIMGUI_API bool ImFontAtlasCustomRect_IsPacked(ImFontAtlasCustomRect* self) {
  return self->IsPacked();
}
CIMGUI_API ImFontAtlas* ImFontAtlas_ImFontAtlas(void) {
  return IM_NEW(ImFontAtlas)();
}
CIMGUI_API void ImFontAtlas_destroy(ImFontAtlas* self) {
  IM_DELETE(self);
}
CIMGUI_API ImFont* ImFontAtlas_AddFont(ImFontAtlas* self,
                                       const ImFontConfig* font_cfg) {
  return self->AddFont(font_cfg);
}
CIMGUI_API ImFont* ImFontAtlas_AddFontDefault(ImFontAtlas* self,
                                              const ImFontConfig* font_cfg) {
  return self->AddFontDefault(font_cfg);
}
CIMGUI_API ImFont* ImFontAtlas_AddFontFromFileTTF(ImFontAtlas* self,
                                                  const char* filename,
                                                  float size_pixels,
                                                  const ImFontConfig* font_cfg,
                                                  const ImWchar* glyph_ranges) {
  return self->AddFontFromFileTTF(filename, size_pixels, font_cfg,
                                  glyph_ranges);
}
CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryTTF(
    ImFontAtlas* self,
    void* font_data,
    int font_data_size,
    float size_pixels,
    const ImFontConfig* font_cfg,
    const ImWchar* glyph_ranges) {
  return self->AddFontFromMemoryTTF(font_data, font_data_size, size_pixels,
                                    font_cfg, glyph_ranges);
}
CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryCompressedTTF(
    ImFontAtlas* self,
    const void* compressed_font_data,
    int compressed_font_data_size,
    float size_pixels,
    const ImFontConfig* font_cfg,
    const ImWchar* glyph_ranges) {
  return self->AddFontFromMemoryCompressedTTF(
      compressed_font_data, compressed_font_data_size, size_pixels, font_cfg,
      glyph_ranges);
}
CIMGUI_API ImFont* ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(
    ImFontAtlas* self,
    const char* compressed_font_data_base85,
    float size_pixels,
    const ImFontConfig* font_cfg,
    const ImWchar* glyph_ranges) {
  return self->AddFontFromMemoryCompressedBase85TTF(
      compressed_font_data_base85, size_pixels, font_cfg, glyph_ranges);
}
CIMGUI_API void ImFontAtlas_ClearInputData(ImFontAtlas* self) {
  return self->ClearInputData();
}
CIMGUI_API void ImFontAtlas_ClearTexData(ImFontAtlas* self) {
  return self->ClearTexData();
}
CIMGUI_API void ImFontAtlas_ClearFonts(ImFontAtlas* self) {
  return self->ClearFonts();
}
CIMGUI_API void ImFontAtlas_Clear(ImFontAtlas* self) {
  return self->Clear();
}
CIMGUI_API bool ImFontAtlas_Build(ImFontAtlas* self) {
  return self->Build();
}
CIMGUI_API void ImFontAtlas_GetTexDataAsAlpha8(ImFontAtlas* self,
                                               unsigned char** out_pixels,
                                               int* out_width,
                                               int* out_height,
                                               int* out_bytes_per_pixel) {
  return self->GetTexDataAsAlpha8(out_pixels, out_width, out_height,
                                  out_bytes_per_pixel);
}
CIMGUI_API void ImFontAtlas_GetTexDataAsRGBA32(ImFontAtlas* self,
                                               unsigned char** out_pixels,
                                               int* out_width,
                                               int* out_height,
                                               int* out_bytes_per_pixel) {
  return self->GetTexDataAsRGBA32(out_pixels, out_width, out_height,
                                  out_bytes_per_pixel);
}
CIMGUI_API bool ImFontAtlas_IsBuilt(ImFontAtlas* self) {
  return self->IsBuilt();
}
CIMGUI_API void ImFontAtlas_SetTexID(ImFontAtlas* self, ImTextureID id) {
  return self->SetTexID(id);
}
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesDefault(ImFontAtlas* self) {
  return self->GetGlyphRangesDefault();
}
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesGreek(ImFontAtlas* self) {
  return self->GetGlyphRangesGreek();
}
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesKorean(ImFontAtlas* self) {
  return self->GetGlyphRangesKorean();
}
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesJapanese(
    ImFontAtlas* self) {
  return self->GetGlyphRangesJapanese();
}
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesChineseFull(
    ImFontAtlas* self) {
  return self->GetGlyphRangesChineseFull();
}
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon(
    ImFontAtlas* self) {
  return self->GetGlyphRangesChineseSimplifiedCommon();
}
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesCyrillic(
    ImFontAtlas* self) {
  return self->GetGlyphRangesCyrillic();
}
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesThai(ImFontAtlas* self) {
  return self->GetGlyphRangesThai();
}
CIMGUI_API const ImWchar* ImFontAtlas_GetGlyphRangesVietnamese(
    ImFontAtlas* self) {
  return self->GetGlyphRangesVietnamese();
}
CIMGUI_API int ImFontAtlas_AddCustomRectRegular(ImFontAtlas* self,
                                                int width,
                                                int height) {
  return self->AddCustomRectRegular(width, height);
}
CIMGUI_API int ImFontAtlas_AddCustomRectFontGlyph(ImFontAtlas* self,
                                                  ImFont* font,
                                                  ImWchar id,
                                                  int width,
                                                  int height,
                                                  float advance_x,
                                                  const ImVec2 offset) {
  return self->AddCustomRectFontGlyph(font, id, width, height, advance_x,
                                      offset);
}
CIMGUI_API ImFontAtlasCustomRect* ImFontAtlas_GetCustomRectByIndex(
    ImFontAtlas* self,
    int index) {
  return self->GetCustomRectByIndex(index);
}
CIMGUI_API void ImFontAtlas_CalcCustomRectUV(ImFontAtlas* self,
                                             const ImFontAtlasCustomRect* rect,
                                             ImVec2* out_uv_min,
                                             ImVec2* out_uv_max) {
  return self->CalcCustomRectUV(rect, out_uv_min, out_uv_max);
}
CIMGUI_API bool ImFontAtlas_GetMouseCursorTexData(ImFontAtlas* self,
                                                  ImGuiMouseCursor cursor,
                                                  ImVec2* out_offset,
                                                  ImVec2* out_size,
                                                  ImVec2 out_uv_border[2],
                                                  ImVec2 out_uv_fill[2]) {
  return self->GetMouseCursorTexData(cursor, out_offset, out_size,
                                     out_uv_border, out_uv_fill);
}
CIMGUI_API ImFont* ImFont_ImFont(void) {
  return IM_NEW(ImFont)();
}
CIMGUI_API void ImFont_destroy(ImFont* self) {
  IM_DELETE(self);
}
CIMGUI_API const ImFontGlyph* ImFont_FindGlyph(ImFont* self, ImWchar c) {
  return self->FindGlyph(c);
}
CIMGUI_API const ImFontGlyph* ImFont_FindGlyphNoFallback(ImFont* self,
                                                         ImWchar c) {
  return self->FindGlyphNoFallback(c);
}
CIMGUI_API float ImFont_GetCharAdvance(ImFont* self, ImWchar c) {
  return self->GetCharAdvance(c);
}
CIMGUI_API bool ImFont_IsLoaded(ImFont* self) {
  return self->IsLoaded();
}
CIMGUI_API const char* ImFont_GetDebugName(ImFont* self) {
  return self->GetDebugName();
}
CIMGUI_API void ImFont_CalcTextSizeA(ImVec2* pOut,
                                     ImFont* self,
                                     float size,
                                     float max_width,
                                     float wrap_width,
                                     const char* text_begin,
                                     const char* text_end,
                                     const char** remaining) {
  *pOut = self->CalcTextSizeA(size, max_width, wrap_width, text_begin, text_end,
                              remaining);
}
CIMGUI_API const char* ImFont_CalcWordWrapPositionA(ImFont* self,
                                                    float scale,
                                                    const char* text,
                                                    const char* text_end,
                                                    float wrap_width) {
  return self->CalcWordWrapPositionA(scale, text, text_end, wrap_width);
}
CIMGUI_API void ImFont_RenderChar(ImFont* self,
                                  ImDrawList* draw_list,
                                  float size,
                                  const ImVec2 pos,
                                  ImU32 col,
                                  ImWchar c) {
  return self->RenderChar(draw_list, size, pos, col, c);
}
CIMGUI_API void ImFont_RenderText(ImFont* self,
                                  ImDrawList* draw_list,
                                  float size,
                                  const ImVec2 pos,
                                  ImU32 col,
                                  const ImVec4 clip_rect,
                                  const char* text_begin,
                                  const char* text_end,
                                  float wrap_width,
                                  bool cpu_fine_clip) {
  return self->RenderText(draw_list, size, pos, col, clip_rect, text_begin,
                          text_end, wrap_width, cpu_fine_clip);
}
CIMGUI_API void ImFont_BuildLookupTable(ImFont* self) {
  return self->BuildLookupTable();
}
CIMGUI_API void ImFont_ClearOutputData(ImFont* self) {
  return self->ClearOutputData();
}
CIMGUI_API void ImFont_GrowIndex(ImFont* self, int new_size) {
  return self->GrowIndex(new_size);
}
CIMGUI_API void ImFont_AddGlyph(ImFont* self,
                                const ImFontConfig* src_cfg,
                                ImWchar c,
                                float x0,
                                float y0,
                                float x1,
                                float y1,
                                float u0,
                                float v0,
                                float u1,
                                float v1,
                                float advance_x) {
  return self->AddGlyph(src_cfg, c, x0, y0, x1, y1, u0, v0, u1, v1, advance_x);
}
CIMGUI_API void ImFont_AddRemapChar(ImFont* self,
                                    ImWchar dst,
                                    ImWchar src,
                                    bool overwrite_dst) {
  return self->AddRemapChar(dst, src, overwrite_dst);
}
CIMGUI_API void ImFont_SetGlyphVisible(ImFont* self, ImWchar c, bool visible) {
  return self->SetGlyphVisible(c, visible);
}
CIMGUI_API bool ImFont_IsGlyphRangeUnused(ImFont* self,
                                          unsigned int c_begin,
                                          unsigned int c_last) {
  return self->IsGlyphRangeUnused(c_begin, c_last);
}
CIMGUI_API ImGuiViewport* ImGuiViewport_ImGuiViewport(void) {
  return IM_NEW(ImGuiViewport)();
}
CIMGUI_API void ImGuiViewport_destroy(ImGuiViewport* self) {
  IM_DELETE(self);
}
CIMGUI_API void ImGuiViewport_GetCenter(ImVec2* pOut, ImGuiViewport* self) {
  *pOut = self->GetCenter();
}
CIMGUI_API void ImGuiViewport_GetWorkCenter(ImVec2* pOut, ImGuiViewport* self) {
  *pOut = self->GetWorkCenter();
}
CIMGUI_API ImGuiPlatformIO* ImGuiPlatformIO_ImGuiPlatformIO(void) {
  return IM_NEW(ImGuiPlatformIO)();
}
CIMGUI_API void ImGuiPlatformIO_destroy(ImGuiPlatformIO* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiPlatformMonitor* ImGuiPlatformMonitor_ImGuiPlatformMonitor(
    void) {
  return IM_NEW(ImGuiPlatformMonitor)();
}
CIMGUI_API void ImGuiPlatformMonitor_destroy(ImGuiPlatformMonitor* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiPlatformImeData* ImGuiPlatformImeData_ImGuiPlatformImeData(
    void) {
  return IM_NEW(ImGuiPlatformImeData)();
}
CIMGUI_API void ImGuiPlatformImeData_destroy(ImGuiPlatformImeData* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiID igImHashData(const void* data,
                                size_t data_size,
                                ImGuiID seed) {
  return ImHashData(data, data_size, seed);
}
CIMGUI_API ImGuiID igImHashStr(const char* data,
                               size_t data_size,
                               ImGuiID seed) {
  return ImHashStr(data, data_size, seed);
}
CIMGUI_API void igImQsort(void* base,
                          size_t count,
                          size_t size_of_element,
                          int (*compare_func)(void const*, void const*)) {
  return ImQsort(base, count, size_of_element, compare_func);
}
CIMGUI_API ImU32 igImAlphaBlendColors(ImU32 col_a, ImU32 col_b) {
  return ImAlphaBlendColors(col_a, col_b);
}
CIMGUI_API bool igImIsPowerOfTwo_Int(int v) {
  return ImIsPowerOfTwo(v);
}
CIMGUI_API bool igImIsPowerOfTwo_U64(ImU64 v) {
  return ImIsPowerOfTwo(v);
}
CIMGUI_API int igImUpperPowerOfTwo(int v) {
  return ImUpperPowerOfTwo(v);
}
CIMGUI_API int igImStricmp(const char* str1, const char* str2) {
  return ImStricmp(str1, str2);
}
CIMGUI_API int igImStrnicmp(const char* str1, const char* str2, size_t count) {
  return ImStrnicmp(str1, str2, count);
}
CIMGUI_API void igImStrncpy(char* dst, const char* src, size_t count) {
  return ImStrncpy(dst, src, count);
}
CIMGUI_API char* igImStrdup(const char* str) {
  return ImStrdup(str);
}
CIMGUI_API char* igImStrdupcpy(char* dst, size_t* p_dst_size, const char* str) {
  return ImStrdupcpy(dst, p_dst_size, str);
}
CIMGUI_API const char* igImStrchrRange(const char* str_begin,
                                       const char* str_end,
                                       char c) {
  return ImStrchrRange(str_begin, str_end, c);
}
CIMGUI_API const char* igImStreolRange(const char* str, const char* str_end) {
  return ImStreolRange(str, str_end);
}
CIMGUI_API const char* igImStristr(const char* haystack,
                                   const char* haystack_end,
                                   const char* needle,
                                   const char* needle_end) {
  return ImStristr(haystack, haystack_end, needle, needle_end);
}
CIMGUI_API void igImStrTrimBlanks(char* str) {
  return ImStrTrimBlanks(str);
}
CIMGUI_API const char* igImStrSkipBlank(const char* str) {
  return ImStrSkipBlank(str);
}
CIMGUI_API int igImStrlenW(const ImWchar* str) {
  return ImStrlenW(str);
}
CIMGUI_API const ImWchar* igImStrbolW(const ImWchar* buf_mid_line,
                                      const ImWchar* buf_begin) {
  return ImStrbolW(buf_mid_line, buf_begin);
}
CIMGUI_API char igImToUpper(char c) {
  return ImToUpper(c);
}
CIMGUI_API bool igImCharIsBlankA(char c) {
  return ImCharIsBlankA(c);
}
CIMGUI_API bool igImCharIsBlankW(unsigned int c) {
  return ImCharIsBlankW(c);
}
CIMGUI_API int igImFormatString(char* buf,
                                size_t buf_size,
                                const char* fmt,
                                ...) {
  va_list args;
  va_start(args, fmt);
  int ret = ImFormatStringV(buf, buf_size, fmt, args);
  va_end(args);
  return ret;
}
CIMGUI_API int igImFormatStringV(char* buf,
                                 size_t buf_size,
                                 const char* fmt,
                                 va_list args) {
  return ImFormatStringV(buf, buf_size, fmt, args);
}
CIMGUI_API void igImFormatStringToTempBuffer(const char** out_buf,
                                             const char** out_buf_end,
                                             const char* fmt,
                                             ...) {
  va_list args;
  va_start(args, fmt);
  ImFormatStringToTempBufferV(out_buf, out_buf_end, fmt, args);
  va_end(args);
}
CIMGUI_API void igImFormatStringToTempBufferV(const char** out_buf,
                                              const char** out_buf_end,
                                              const char* fmt,
                                              va_list args) {
  return ImFormatStringToTempBufferV(out_buf, out_buf_end, fmt, args);
}
CIMGUI_API const char* igImParseFormatFindStart(const char* format) {
  return ImParseFormatFindStart(format);
}
CIMGUI_API const char* igImParseFormatFindEnd(const char* format) {
  return ImParseFormatFindEnd(format);
}
CIMGUI_API const char* igImParseFormatTrimDecorations(const char* format,
                                                      char* buf,
                                                      size_t buf_size) {
  return ImParseFormatTrimDecorations(format, buf, buf_size);
}
CIMGUI_API void igImParseFormatSanitizeForPrinting(const char* fmt_in,
                                                   char* fmt_out,
                                                   size_t fmt_out_size) {
  return ImParseFormatSanitizeForPrinting(fmt_in, fmt_out, fmt_out_size);
}
CIMGUI_API const char* igImParseFormatSanitizeForScanning(const char* fmt_in,
                                                          char* fmt_out,
                                                          size_t fmt_out_size) {
  return ImParseFormatSanitizeForScanning(fmt_in, fmt_out, fmt_out_size);
}
CIMGUI_API int igImParseFormatPrecision(const char* format, int default_value) {
  return ImParseFormatPrecision(format, default_value);
}
CIMGUI_API const char* igImTextCharToUtf8(char out_buf[5], unsigned int c) {
  return ImTextCharToUtf8(out_buf, c);
}
CIMGUI_API int igImTextStrToUtf8(char* out_buf,
                                 int out_buf_size,
                                 const ImWchar* in_text,
                                 const ImWchar* in_text_end) {
  return ImTextStrToUtf8(out_buf, out_buf_size, in_text, in_text_end);
}
CIMGUI_API int igImTextCharFromUtf8(unsigned int* out_char,
                                    const char* in_text,
                                    const char* in_text_end) {
  return ImTextCharFromUtf8(out_char, in_text, in_text_end);
}
CIMGUI_API int igImTextStrFromUtf8(ImWchar* out_buf,
                                   int out_buf_size,
                                   const char* in_text,
                                   const char* in_text_end,
                                   const char** in_remaining) {
  return ImTextStrFromUtf8(out_buf, out_buf_size, in_text, in_text_end,
                           in_remaining);
}
CIMGUI_API int igImTextCountCharsFromUtf8(const char* in_text,
                                          const char* in_text_end) {
  return ImTextCountCharsFromUtf8(in_text, in_text_end);
}
CIMGUI_API int igImTextCountUtf8BytesFromChar(const char* in_text,
                                              const char* in_text_end) {
  return ImTextCountUtf8BytesFromChar(in_text, in_text_end);
}
CIMGUI_API int igImTextCountUtf8BytesFromStr(const ImWchar* in_text,
                                             const ImWchar* in_text_end) {
  return ImTextCountUtf8BytesFromStr(in_text, in_text_end);
}
CIMGUI_API const char* igImTextFindPreviousUtf8Codepoint(
    const char* in_text_start,
    const char* in_text_curr) {
  return ImTextFindPreviousUtf8Codepoint(in_text_start, in_text_curr);
}
CIMGUI_API int igImTextCountLines(const char* in_text,
                                  const char* in_text_end) {
  return ImTextCountLines(in_text, in_text_end);
}
CIMGUI_API ImFileHandle igImFileOpen(const char* filename, const char* mode) {
  return ImFileOpen(filename, mode);
}
CIMGUI_API bool igImFileClose(ImFileHandle file) {
  return ImFileClose(file);
}
CIMGUI_API ImU64 igImFileGetSize(ImFileHandle file) {
  return ImFileGetSize(file);
}
CIMGUI_API ImU64 igImFileRead(void* data,
                              ImU64 size,
                              ImU64 count,
                              ImFileHandle file) {
  return ImFileRead(data, size, count, file);
}
CIMGUI_API ImU64 igImFileWrite(const void* data,
                               ImU64 size,
                               ImU64 count,
                               ImFileHandle file) {
  return ImFileWrite(data, size, count, file);
}
CIMGUI_API void* igImFileLoadToMemory(const char* filename,
                                      const char* mode,
                                      size_t* out_file_size,
                                      int padding_bytes) {
  return ImFileLoadToMemory(filename, mode, out_file_size, padding_bytes);
}
CIMGUI_API float igImPow_Float(float x, float y) {
  return ImPow(x, y);
}
CIMGUI_API double igImPow_double(double x, double y) {
  return ImPow(x, y);
}
CIMGUI_API float igImLog_Float(float x) {
  return ImLog(x);
}
CIMGUI_API double igImLog_double(double x) {
  return ImLog(x);
}
CIMGUI_API int igImAbs_Int(int x) {
  return ImAbs(x);
}
CIMGUI_API float igImAbs_Float(float x) {
  return ImAbs(x);
}
CIMGUI_API double igImAbs_double(double x) {
  return ImAbs(x);
}
CIMGUI_API float igImSign_Float(float x) {
  return ImSign(x);
}
CIMGUI_API double igImSign_double(double x) {
  return ImSign(x);
}
CIMGUI_API float igImRsqrt_Float(float x) {
  return ImRsqrt(x);
}
CIMGUI_API double igImRsqrt_double(double x) {
  return ImRsqrt(x);
}
CIMGUI_API void igImMin(ImVec2* pOut, const ImVec2 lhs, const ImVec2 rhs) {
  *pOut = ImMin(lhs, rhs);
}
CIMGUI_API void igImMax(ImVec2* pOut, const ImVec2 lhs, const ImVec2 rhs) {
  *pOut = ImMax(lhs, rhs);
}
CIMGUI_API void igImClamp(ImVec2* pOut,
                          const ImVec2 v,
                          const ImVec2 mn,
                          ImVec2 mx) {
  *pOut = ImClamp(v, mn, mx);
}
CIMGUI_API void igImLerp_Vec2Float(ImVec2* pOut,
                                   const ImVec2 a,
                                   const ImVec2 b,
                                   float t) {
  *pOut = ImLerp(a, b, t);
}
CIMGUI_API void igImLerp_Vec2Vec2(ImVec2* pOut,
                                  const ImVec2 a,
                                  const ImVec2 b,
                                  const ImVec2 t) {
  *pOut = ImLerp(a, b, t);
}
CIMGUI_API void igImLerp_Vec4(ImVec4* pOut,
                              const ImVec4 a,
                              const ImVec4 b,
                              float t) {
  *pOut = ImLerp(a, b, t);
}
CIMGUI_API float igImSaturate(float f) {
  return ImSaturate(f);
}
CIMGUI_API float igImLengthSqr_Vec2(const ImVec2 lhs) {
  return ImLengthSqr(lhs);
}
CIMGUI_API float igImLengthSqr_Vec4(const ImVec4 lhs) {
  return ImLengthSqr(lhs);
}
CIMGUI_API float igImInvLength(const ImVec2 lhs, float fail_value) {
  return ImInvLength(lhs, fail_value);
}
CIMGUI_API float igImTrunc_Float(float f) {
  return ImTrunc(f);
}
CIMGUI_API void igImTrunc_Vec2(ImVec2* pOut, const ImVec2 v) {
  *pOut = ImTrunc(v);
}
CIMGUI_API float igImFloor_Float(float f) {
  return ImFloor(f);
}
CIMGUI_API void igImFloor_Vec2(ImVec2* pOut, const ImVec2 v) {
  *pOut = ImFloor(v);
}
CIMGUI_API int igImModPositive(int a, int b) {
  return ImModPositive(a, b);
}
CIMGUI_API float igImDot(const ImVec2 a, const ImVec2 b) {
  return ImDot(a, b);
}
CIMGUI_API void igImRotate(ImVec2* pOut,
                           const ImVec2 v,
                           float cos_a,
                           float sin_a) {
  *pOut = ImRotate(v, cos_a, sin_a);
}
CIMGUI_API float igImLinearSweep(float current, float target, float speed) {
  return ImLinearSweep(current, target, speed);
}
CIMGUI_API void igImMul(ImVec2* pOut, const ImVec2 lhs, const ImVec2 rhs) {
  *pOut = ImMul(lhs, rhs);
}
CIMGUI_API bool igImIsFloatAboveGuaranteedIntegerPrecision(float f) {
  return ImIsFloatAboveGuaranteedIntegerPrecision(f);
}
CIMGUI_API float igImExponentialMovingAverage(float avg, float sample, int n) {
  return ImExponentialMovingAverage(avg, sample, n);
}
CIMGUI_API void igImBezierCubicCalc(ImVec2* pOut,
                                    const ImVec2 p1,
                                    const ImVec2 p2,
                                    const ImVec2 p3,
                                    const ImVec2 p4,
                                    float t) {
  *pOut = ImBezierCubicCalc(p1, p2, p3, p4, t);
}
CIMGUI_API void igImBezierCubicClosestPoint(ImVec2* pOut,
                                            const ImVec2 p1,
                                            const ImVec2 p2,
                                            const ImVec2 p3,
                                            const ImVec2 p4,
                                            const ImVec2 p,
                                            int num_segments) {
  *pOut = ImBezierCubicClosestPoint(p1, p2, p3, p4, p, num_segments);
}
CIMGUI_API void igImBezierCubicClosestPointCasteljau(ImVec2* pOut,
                                                     const ImVec2 p1,
                                                     const ImVec2 p2,
                                                     const ImVec2 p3,
                                                     const ImVec2 p4,
                                                     const ImVec2 p,
                                                     float tess_tol) {
  *pOut = ImBezierCubicClosestPointCasteljau(p1, p2, p3, p4, p, tess_tol);
}
CIMGUI_API void igImBezierQuadraticCalc(ImVec2* pOut,
                                        const ImVec2 p1,
                                        const ImVec2 p2,
                                        const ImVec2 p3,
                                        float t) {
  *pOut = ImBezierQuadraticCalc(p1, p2, p3, t);
}
CIMGUI_API void igImLineClosestPoint(ImVec2* pOut,
                                     const ImVec2 a,
                                     const ImVec2 b,
                                     const ImVec2 p) {
  *pOut = ImLineClosestPoint(a, b, p);
}
CIMGUI_API bool igImTriangleContainsPoint(const ImVec2 a,
                                          const ImVec2 b,
                                          const ImVec2 c,
                                          const ImVec2 p) {
  return ImTriangleContainsPoint(a, b, c, p);
}
CIMGUI_API void igImTriangleClosestPoint(ImVec2* pOut,
                                         const ImVec2 a,
                                         const ImVec2 b,
                                         const ImVec2 c,
                                         const ImVec2 p) {
  *pOut = ImTriangleClosestPoint(a, b, c, p);
}
CIMGUI_API void igImTriangleBarycentricCoords(const ImVec2 a,
                                              const ImVec2 b,
                                              const ImVec2 c,
                                              const ImVec2 p,
                                              float* out_u,
                                              float* out_v,
                                              float* out_w) {
  return ImTriangleBarycentricCoords(a, b, c, p, *out_u, *out_v, *out_w);
}
CIMGUI_API float igImTriangleArea(const ImVec2 a,
                                  const ImVec2 b,
                                  const ImVec2 c) {
  return ImTriangleArea(a, b, c);
}
CIMGUI_API bool igImTriangleIsClockwise(const ImVec2 a,
                                        const ImVec2 b,
                                        const ImVec2 c) {
  return ImTriangleIsClockwise(a, b, c);
}
CIMGUI_API ImVec1* ImVec1_ImVec1_Nil(void) {
  return IM_NEW(ImVec1)();
}
CIMGUI_API void ImVec1_destroy(ImVec1* self) {
  IM_DELETE(self);
}
CIMGUI_API ImVec1* ImVec1_ImVec1_Float(float _x) {
  return IM_NEW(ImVec1)(_x);
}
CIMGUI_API ImVec2ih* ImVec2ih_ImVec2ih_Nil(void) {
  return IM_NEW(ImVec2ih)();
}
CIMGUI_API void ImVec2ih_destroy(ImVec2ih* self) {
  IM_DELETE(self);
}
CIMGUI_API ImVec2ih* ImVec2ih_ImVec2ih_short(short _x, short _y) {
  return IM_NEW(ImVec2ih)(_x, _y);
}
CIMGUI_API ImVec2ih* ImVec2ih_ImVec2ih_Vec2(const ImVec2 rhs) {
  return IM_NEW(ImVec2ih)(rhs);
}
CIMGUI_API ImRect* ImRect_ImRect_Nil(void) {
  return IM_NEW(ImRect)();
}
CIMGUI_API void ImRect_destroy(ImRect* self) {
  IM_DELETE(self);
}
CIMGUI_API ImRect* ImRect_ImRect_Vec2(const ImVec2 min, const ImVec2 max) {
  return IM_NEW(ImRect)(min, max);
}
CIMGUI_API ImRect* ImRect_ImRect_Vec4(const ImVec4 v) {
  return IM_NEW(ImRect)(v);
}
CIMGUI_API ImRect* ImRect_ImRect_Float(float x1, float y1, float x2, float y2) {
  return IM_NEW(ImRect)(x1, y1, x2, y2);
}
CIMGUI_API void ImRect_GetCenter(ImVec2* pOut, ImRect* self) {
  *pOut = self->GetCenter();
}
CIMGUI_API void ImRect_GetSize(ImVec2* pOut, ImRect* self) {
  *pOut = self->GetSize();
}
CIMGUI_API float ImRect_GetWidth(ImRect* self) {
  return self->GetWidth();
}
CIMGUI_API float ImRect_GetHeight(ImRect* self) {
  return self->GetHeight();
}
CIMGUI_API float ImRect_GetArea(ImRect* self) {
  return self->GetArea();
}
CIMGUI_API void ImRect_GetTL(ImVec2* pOut, ImRect* self) {
  *pOut = self->GetTL();
}
CIMGUI_API void ImRect_GetTR(ImVec2* pOut, ImRect* self) {
  *pOut = self->GetTR();
}
CIMGUI_API void ImRect_GetBL(ImVec2* pOut, ImRect* self) {
  *pOut = self->GetBL();
}
CIMGUI_API void ImRect_GetBR(ImVec2* pOut, ImRect* self) {
  *pOut = self->GetBR();
}
CIMGUI_API bool ImRect_Contains_Vec2(ImRect* self, const ImVec2 p) {
  return self->Contains(p);
}
CIMGUI_API bool ImRect_Contains_Rect(ImRect* self, const ImRect r) {
  return self->Contains(r);
}
CIMGUI_API bool ImRect_ContainsWithPad(ImRect* self,
                                       const ImVec2 p,
                                       const ImVec2 pad) {
  return self->ContainsWithPad(p, pad);
}
CIMGUI_API bool ImRect_Overlaps(ImRect* self, const ImRect r) {
  return self->Overlaps(r);
}
CIMGUI_API void ImRect_Add_Vec2(ImRect* self, const ImVec2 p) {
  return self->Add(p);
}
CIMGUI_API void ImRect_Add_Rect(ImRect* self, const ImRect r) {
  return self->Add(r);
}
CIMGUI_API void ImRect_Expand_Float(ImRect* self, const float amount) {
  return self->Expand(amount);
}
CIMGUI_API void ImRect_Expand_Vec2(ImRect* self, const ImVec2 amount) {
  return self->Expand(amount);
}
CIMGUI_API void ImRect_Translate(ImRect* self, const ImVec2 d) {
  return self->Translate(d);
}
CIMGUI_API void ImRect_TranslateX(ImRect* self, float dx) {
  return self->TranslateX(dx);
}
CIMGUI_API void ImRect_TranslateY(ImRect* self, float dy) {
  return self->TranslateY(dy);
}
CIMGUI_API void ImRect_ClipWith(ImRect* self, const ImRect r) {
  return self->ClipWith(r);
}
CIMGUI_API void ImRect_ClipWithFull(ImRect* self, const ImRect r) {
  return self->ClipWithFull(r);
}
CIMGUI_API void ImRect_Floor(ImRect* self) {
  return self->Floor();
}
CIMGUI_API bool ImRect_IsInverted(ImRect* self) {
  return self->IsInverted();
}
CIMGUI_API void ImRect_ToVec4(ImVec4* pOut, ImRect* self) {
  *pOut = self->ToVec4();
}
CIMGUI_API size_t igImBitArrayGetStorageSizeInBytes(int bitcount) {
  return ImBitArrayGetStorageSizeInBytes(bitcount);
}
CIMGUI_API void igImBitArrayClearAllBits(ImU32* arr, int bitcount) {
  return ImBitArrayClearAllBits(arr, bitcount);
}
CIMGUI_API bool igImBitArrayTestBit(const ImU32* arr, int n) {
  return ImBitArrayTestBit(arr, n);
}
CIMGUI_API void igImBitArrayClearBit(ImU32* arr, int n) {
  return ImBitArrayClearBit(arr, n);
}
CIMGUI_API void igImBitArraySetBit(ImU32* arr, int n) {
  return ImBitArraySetBit(arr, n);
}
CIMGUI_API void igImBitArraySetBitRange(ImU32* arr, int n, int n2) {
  return ImBitArraySetBitRange(arr, n, n2);
}
CIMGUI_API void ImBitVector_Create(ImBitVector* self, int sz) {
  return self->Create(sz);
}
CIMGUI_API void ImBitVector_Clear(ImBitVector* self) {
  return self->Clear();
}
CIMGUI_API bool ImBitVector_TestBit(ImBitVector* self, int n) {
  return self->TestBit(n);
}
CIMGUI_API void ImBitVector_SetBit(ImBitVector* self, int n) {
  return self->SetBit(n);
}
CIMGUI_API void ImBitVector_ClearBit(ImBitVector* self, int n) {
  return self->ClearBit(n);
}
CIMGUI_API void ImGuiTextIndex_clear(ImGuiTextIndex* self) {
  return self->clear();
}
CIMGUI_API int ImGuiTextIndex_size(ImGuiTextIndex* self) {
  return self->size();
}
CIMGUI_API const char* ImGuiTextIndex_get_line_begin(ImGuiTextIndex* self,
                                                     const char* base,
                                                     int n) {
  return self->get_line_begin(base, n);
}
CIMGUI_API const char* ImGuiTextIndex_get_line_end(ImGuiTextIndex* self,
                                                   const char* base,
                                                   int n) {
  return self->get_line_end(base, n);
}
CIMGUI_API void ImGuiTextIndex_append(ImGuiTextIndex* self,
                                      const char* base,
                                      int old_size,
                                      int new_size) {
  return self->append(base, old_size, new_size);
}
CIMGUI_API ImDrawListSharedData* ImDrawListSharedData_ImDrawListSharedData(
    void) {
  return IM_NEW(ImDrawListSharedData)();
}
CIMGUI_API void ImDrawListSharedData_destroy(ImDrawListSharedData* self) {
  IM_DELETE(self);
}
CIMGUI_API void ImDrawListSharedData_SetCircleTessellationMaxError(
    ImDrawListSharedData* self,
    float max_error) {
  return self->SetCircleTessellationMaxError(max_error);
}
CIMGUI_API ImDrawDataBuilder* ImDrawDataBuilder_ImDrawDataBuilder(void) {
  return IM_NEW(ImDrawDataBuilder)();
}
CIMGUI_API void ImDrawDataBuilder_destroy(ImDrawDataBuilder* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiStyleMod* ImGuiStyleMod_ImGuiStyleMod_Int(ImGuiStyleVar idx,
                                                          int v) {
  return IM_NEW(ImGuiStyleMod)(idx, v);
}
CIMGUI_API void ImGuiStyleMod_destroy(ImGuiStyleMod* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiStyleMod* ImGuiStyleMod_ImGuiStyleMod_Float(ImGuiStyleVar idx,
                                                            float v) {
  return IM_NEW(ImGuiStyleMod)(idx, v);
}
CIMGUI_API ImGuiStyleMod* ImGuiStyleMod_ImGuiStyleMod_Vec2(ImGuiStyleVar idx,
                                                           ImVec2 v) {
  return IM_NEW(ImGuiStyleMod)(idx, v);
}
CIMGUI_API ImGuiComboPreviewData* ImGuiComboPreviewData_ImGuiComboPreviewData(
    void) {
  return IM_NEW(ImGuiComboPreviewData)();
}
CIMGUI_API void ImGuiComboPreviewData_destroy(ImGuiComboPreviewData* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiMenuColumns* ImGuiMenuColumns_ImGuiMenuColumns(void) {
  return IM_NEW(ImGuiMenuColumns)();
}
CIMGUI_API void ImGuiMenuColumns_destroy(ImGuiMenuColumns* self) {
  IM_DELETE(self);
}
CIMGUI_API void ImGuiMenuColumns_Update(ImGuiMenuColumns* self,
                                        float spacing,
                                        bool window_reappearing) {
  return self->Update(spacing, window_reappearing);
}
CIMGUI_API float ImGuiMenuColumns_DeclColumns(ImGuiMenuColumns* self,
                                              float w_icon,
                                              float w_label,
                                              float w_shortcut,
                                              float w_mark) {
  return self->DeclColumns(w_icon, w_label, w_shortcut, w_mark);
}
CIMGUI_API void ImGuiMenuColumns_CalcNextTotalWidth(ImGuiMenuColumns* self,
                                                    bool update_offsets) {
  return self->CalcNextTotalWidth(update_offsets);
}
CIMGUI_API ImGuiInputTextDeactivatedState*
ImGuiInputTextDeactivatedState_ImGuiInputTextDeactivatedState(void) {
  return IM_NEW(ImGuiInputTextDeactivatedState)();
}
CIMGUI_API void ImGuiInputTextDeactivatedState_destroy(
    ImGuiInputTextDeactivatedState* self) {
  IM_DELETE(self);
}
CIMGUI_API void ImGuiInputTextDeactivatedState_ClearFreeMemory(
    ImGuiInputTextDeactivatedState* self) {
  return self->ClearFreeMemory();
}
CIMGUI_API ImGuiInputTextState* ImGuiInputTextState_ImGuiInputTextState(void) {
  return IM_NEW(ImGuiInputTextState)();
}
CIMGUI_API void ImGuiInputTextState_destroy(ImGuiInputTextState* self) {
  IM_DELETE(self);
}
CIMGUI_API void ImGuiInputTextState_ClearText(ImGuiInputTextState* self) {
  return self->ClearText();
}
CIMGUI_API void ImGuiInputTextState_ClearFreeMemory(ImGuiInputTextState* self) {
  return self->ClearFreeMemory();
}
CIMGUI_API int ImGuiInputTextState_GetUndoAvailCount(
    ImGuiInputTextState* self) {
  return self->GetUndoAvailCount();
}
CIMGUI_API int ImGuiInputTextState_GetRedoAvailCount(
    ImGuiInputTextState* self) {
  return self->GetRedoAvailCount();
}
CIMGUI_API void ImGuiInputTextState_OnKeyPressed(ImGuiInputTextState* self,
                                                 int key) {
  return self->OnKeyPressed(key);
}
CIMGUI_API void ImGuiInputTextState_CursorAnimReset(ImGuiInputTextState* self) {
  return self->CursorAnimReset();
}
CIMGUI_API void ImGuiInputTextState_CursorClamp(ImGuiInputTextState* self) {
  return self->CursorClamp();
}
CIMGUI_API bool ImGuiInputTextState_HasSelection(ImGuiInputTextState* self) {
  return self->HasSelection();
}
CIMGUI_API void ImGuiInputTextState_ClearSelection(ImGuiInputTextState* self) {
  return self->ClearSelection();
}
CIMGUI_API int ImGuiInputTextState_GetCursorPos(ImGuiInputTextState* self) {
  return self->GetCursorPos();
}
CIMGUI_API int ImGuiInputTextState_GetSelectionStart(
    ImGuiInputTextState* self) {
  return self->GetSelectionStart();
}
CIMGUI_API int ImGuiInputTextState_GetSelectionEnd(ImGuiInputTextState* self) {
  return self->GetSelectionEnd();
}
CIMGUI_API void ImGuiInputTextState_SelectAll(ImGuiInputTextState* self) {
  return self->SelectAll();
}
CIMGUI_API void ImGuiInputTextState_ReloadUserBufAndSelectAll(
    ImGuiInputTextState* self) {
  return self->ReloadUserBufAndSelectAll();
}
CIMGUI_API void ImGuiInputTextState_ReloadUserBufAndKeepSelection(
    ImGuiInputTextState* self) {
  return self->ReloadUserBufAndKeepSelection();
}
CIMGUI_API void ImGuiInputTextState_ReloadUserBufAndMoveToEnd(
    ImGuiInputTextState* self) {
  return self->ReloadUserBufAndMoveToEnd();
}
CIMGUI_API ImGuiNextWindowData* ImGuiNextWindowData_ImGuiNextWindowData(void) {
  return IM_NEW(ImGuiNextWindowData)();
}
CIMGUI_API void ImGuiNextWindowData_destroy(ImGuiNextWindowData* self) {
  IM_DELETE(self);
}
CIMGUI_API void ImGuiNextWindowData_ClearFlags(ImGuiNextWindowData* self) {
  return self->ClearFlags();
}
CIMGUI_API ImGuiNextItemData* ImGuiNextItemData_ImGuiNextItemData(void) {
  return IM_NEW(ImGuiNextItemData)();
}
CIMGUI_API void ImGuiNextItemData_destroy(ImGuiNextItemData* self) {
  IM_DELETE(self);
}
CIMGUI_API void ImGuiNextItemData_ClearFlags(ImGuiNextItemData* self) {
  return self->ClearFlags();
}
CIMGUI_API ImGuiLastItemData* ImGuiLastItemData_ImGuiLastItemData(void) {
  return IM_NEW(ImGuiLastItemData)();
}
CIMGUI_API void ImGuiLastItemData_destroy(ImGuiLastItemData* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiStackSizes* ImGuiStackSizes_ImGuiStackSizes(void) {
  return IM_NEW(ImGuiStackSizes)();
}
CIMGUI_API void ImGuiStackSizes_destroy(ImGuiStackSizes* self) {
  IM_DELETE(self);
}
CIMGUI_API void ImGuiStackSizes_SetToContextState(ImGuiStackSizes* self,
                                                  ImGuiContext* ctx) {
  return self->SetToContextState(ctx);
}
CIMGUI_API void ImGuiStackSizes_CompareWithContextState(ImGuiStackSizes* self,
                                                        ImGuiContext* ctx) {
  return self->CompareWithContextState(ctx);
}
CIMGUI_API ImGuiPtrOrIndex* ImGuiPtrOrIndex_ImGuiPtrOrIndex_Ptr(void* ptr) {
  return IM_NEW(ImGuiPtrOrIndex)(ptr);
}
CIMGUI_API void ImGuiPtrOrIndex_destroy(ImGuiPtrOrIndex* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiPtrOrIndex* ImGuiPtrOrIndex_ImGuiPtrOrIndex_Int(int index) {
  return IM_NEW(ImGuiPtrOrIndex)(index);
}
CIMGUI_API void* ImGuiDataVarInfo_GetVarPtr(ImGuiDataVarInfo* self,
                                            void* parent) {
  return self->GetVarPtr(parent);
}
CIMGUI_API ImGuiPopupData* ImGuiPopupData_ImGuiPopupData(void) {
  return IM_NEW(ImGuiPopupData)();
}
CIMGUI_API void ImGuiPopupData_destroy(ImGuiPopupData* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiInputEvent* ImGuiInputEvent_ImGuiInputEvent(void) {
  return IM_NEW(ImGuiInputEvent)();
}
CIMGUI_API void ImGuiInputEvent_destroy(ImGuiInputEvent* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiKeyRoutingData* ImGuiKeyRoutingData_ImGuiKeyRoutingData(void) {
  return IM_NEW(ImGuiKeyRoutingData)();
}
CIMGUI_API void ImGuiKeyRoutingData_destroy(ImGuiKeyRoutingData* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiKeyRoutingTable* ImGuiKeyRoutingTable_ImGuiKeyRoutingTable(
    void) {
  return IM_NEW(ImGuiKeyRoutingTable)();
}
CIMGUI_API void ImGuiKeyRoutingTable_destroy(ImGuiKeyRoutingTable* self) {
  IM_DELETE(self);
}
CIMGUI_API void ImGuiKeyRoutingTable_Clear(ImGuiKeyRoutingTable* self) {
  return self->Clear();
}
CIMGUI_API ImGuiKeyOwnerData* ImGuiKeyOwnerData_ImGuiKeyOwnerData(void) {
  return IM_NEW(ImGuiKeyOwnerData)();
}
CIMGUI_API void ImGuiKeyOwnerData_destroy(ImGuiKeyOwnerData* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiListClipperRange ImGuiListClipperRange_FromIndices(int min,
                                                                   int max) {
  return ImGuiListClipperRange::FromIndices(min, max);
}
CIMGUI_API ImGuiListClipperRange
ImGuiListClipperRange_FromPositions(float y1,
                                    float y2,
                                    int off_min,
                                    int off_max) {
  return ImGuiListClipperRange::FromPositions(y1, y2, off_min, off_max);
}
CIMGUI_API ImGuiListClipperData* ImGuiListClipperData_ImGuiListClipperData(
    void) {
  return IM_NEW(ImGuiListClipperData)();
}
CIMGUI_API void ImGuiListClipperData_destroy(ImGuiListClipperData* self) {
  IM_DELETE(self);
}
CIMGUI_API void ImGuiListClipperData_Reset(ImGuiListClipperData* self,
                                           ImGuiListClipper* clipper) {
  return self->Reset(clipper);
}
CIMGUI_API ImGuiNavItemData* ImGuiNavItemData_ImGuiNavItemData(void) {
  return IM_NEW(ImGuiNavItemData)();
}
CIMGUI_API void ImGuiNavItemData_destroy(ImGuiNavItemData* self) {
  IM_DELETE(self);
}
CIMGUI_API void ImGuiNavItemData_Clear(ImGuiNavItemData* self) {
  return self->Clear();
}
CIMGUI_API ImGuiTypingSelectState*
ImGuiTypingSelectState_ImGuiTypingSelectState(void) {
  return IM_NEW(ImGuiTypingSelectState)();
}
CIMGUI_API void ImGuiTypingSelectState_destroy(ImGuiTypingSelectState* self) {
  IM_DELETE(self);
}
CIMGUI_API void ImGuiTypingSelectState_Clear(ImGuiTypingSelectState* self) {
  return self->Clear();
}
CIMGUI_API ImGuiOldColumnData* ImGuiOldColumnData_ImGuiOldColumnData(void) {
  return IM_NEW(ImGuiOldColumnData)();
}
CIMGUI_API void ImGuiOldColumnData_destroy(ImGuiOldColumnData* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiOldColumns* ImGuiOldColumns_ImGuiOldColumns(void) {
  return IM_NEW(ImGuiOldColumns)();
}
CIMGUI_API void ImGuiOldColumns_destroy(ImGuiOldColumns* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiDockNode* ImGuiDockNode_ImGuiDockNode(ImGuiID id) {
  return IM_NEW(ImGuiDockNode)(id);
}
CIMGUI_API void ImGuiDockNode_destroy(ImGuiDockNode* self) {
  IM_DELETE(self);
}
CIMGUI_API bool ImGuiDockNode_IsRootNode(ImGuiDockNode* self) {
  return self->IsRootNode();
}
CIMGUI_API bool ImGuiDockNode_IsDockSpace(ImGuiDockNode* self) {
  return self->IsDockSpace();
}
CIMGUI_API bool ImGuiDockNode_IsFloatingNode(ImGuiDockNode* self) {
  return self->IsFloatingNode();
}
CIMGUI_API bool ImGuiDockNode_IsCentralNode(ImGuiDockNode* self) {
  return self->IsCentralNode();
}
CIMGUI_API bool ImGuiDockNode_IsHiddenTabBar(ImGuiDockNode* self) {
  return self->IsHiddenTabBar();
}
CIMGUI_API bool ImGuiDockNode_IsNoTabBar(ImGuiDockNode* self) {
  return self->IsNoTabBar();
}
CIMGUI_API bool ImGuiDockNode_IsSplitNode(ImGuiDockNode* self) {
  return self->IsSplitNode();
}
CIMGUI_API bool ImGuiDockNode_IsLeafNode(ImGuiDockNode* self) {
  return self->IsLeafNode();
}
CIMGUI_API bool ImGuiDockNode_IsEmpty(ImGuiDockNode* self) {
  return self->IsEmpty();
}
CIMGUI_API void ImGuiDockNode_Rect(ImRect* pOut, ImGuiDockNode* self) {
  *pOut = self->Rect();
}
CIMGUI_API void ImGuiDockNode_SetLocalFlags(ImGuiDockNode* self,
                                            ImGuiDockNodeFlags flags) {
  return self->SetLocalFlags(flags);
}
CIMGUI_API void ImGuiDockNode_UpdateMergedFlags(ImGuiDockNode* self) {
  return self->UpdateMergedFlags();
}
CIMGUI_API ImGuiDockContext* ImGuiDockContext_ImGuiDockContext(void) {
  return IM_NEW(ImGuiDockContext)();
}
CIMGUI_API void ImGuiDockContext_destroy(ImGuiDockContext* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiViewportP* ImGuiViewportP_ImGuiViewportP(void) {
  return IM_NEW(ImGuiViewportP)();
}
CIMGUI_API void ImGuiViewportP_destroy(ImGuiViewportP* self) {
  IM_DELETE(self);
}
CIMGUI_API void ImGuiViewportP_ClearRequestFlags(ImGuiViewportP* self) {
  return self->ClearRequestFlags();
}
CIMGUI_API void ImGuiViewportP_CalcWorkRectPos(ImVec2* pOut,
                                               ImGuiViewportP* self,
                                               const ImVec2 off_min) {
  *pOut = self->CalcWorkRectPos(off_min);
}
CIMGUI_API void ImGuiViewportP_CalcWorkRectSize(ImVec2* pOut,
                                                ImGuiViewportP* self,
                                                const ImVec2 off_min,
                                                const ImVec2 off_max) {
  *pOut = self->CalcWorkRectSize(off_min, off_max);
}
CIMGUI_API void ImGuiViewportP_UpdateWorkRect(ImGuiViewportP* self) {
  return self->UpdateWorkRect();
}
CIMGUI_API void ImGuiViewportP_GetMainRect(ImRect* pOut, ImGuiViewportP* self) {
  *pOut = self->GetMainRect();
}
CIMGUI_API void ImGuiViewportP_GetWorkRect(ImRect* pOut, ImGuiViewportP* self) {
  *pOut = self->GetWorkRect();
}
CIMGUI_API void ImGuiViewportP_GetBuildWorkRect(ImRect* pOut,
                                                ImGuiViewportP* self) {
  *pOut = self->GetBuildWorkRect();
}
CIMGUI_API ImGuiWindowSettings* ImGuiWindowSettings_ImGuiWindowSettings(void) {
  return IM_NEW(ImGuiWindowSettings)();
}
CIMGUI_API void ImGuiWindowSettings_destroy(ImGuiWindowSettings* self) {
  IM_DELETE(self);
}
CIMGUI_API char* ImGuiWindowSettings_GetName(ImGuiWindowSettings* self) {
  return self->GetName();
}
CIMGUI_API ImGuiSettingsHandler* ImGuiSettingsHandler_ImGuiSettingsHandler(
    void) {
  return IM_NEW(ImGuiSettingsHandler)();
}
CIMGUI_API void ImGuiSettingsHandler_destroy(ImGuiSettingsHandler* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiDebugAllocInfo* ImGuiDebugAllocInfo_ImGuiDebugAllocInfo(void) {
  return IM_NEW(ImGuiDebugAllocInfo)();
}
CIMGUI_API void ImGuiDebugAllocInfo_destroy(ImGuiDebugAllocInfo* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiStackLevelInfo* ImGuiStackLevelInfo_ImGuiStackLevelInfo(void) {
  return IM_NEW(ImGuiStackLevelInfo)();
}
CIMGUI_API void ImGuiStackLevelInfo_destroy(ImGuiStackLevelInfo* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiIDStackTool* ImGuiIDStackTool_ImGuiIDStackTool(void) {
  return IM_NEW(ImGuiIDStackTool)();
}
CIMGUI_API void ImGuiIDStackTool_destroy(ImGuiIDStackTool* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiContextHook* ImGuiContextHook_ImGuiContextHook(void) {
  return IM_NEW(ImGuiContextHook)();
}
CIMGUI_API void ImGuiContextHook_destroy(ImGuiContextHook* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiContext* ImGuiContext_ImGuiContext(
    ImFontAtlas* shared_font_atlas) {
  return IM_NEW(ImGuiContext)(shared_font_atlas);
}
CIMGUI_API void ImGuiContext_destroy(ImGuiContext* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiWindow* ImGuiWindow_ImGuiWindow(ImGuiContext* context,
                                                const char* name) {
  return IM_NEW(ImGuiWindow)(context, name);
}
CIMGUI_API void ImGuiWindow_destroy(ImGuiWindow* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiID ImGuiWindow_GetID_Str(ImGuiWindow* self,
                                         const char* str,
                                         const char* str_end) {
  return self->GetID(str, str_end);
}
CIMGUI_API ImGuiID ImGuiWindow_GetID_Ptr(ImGuiWindow* self, const void* ptr) {
  return self->GetID(ptr);
}
CIMGUI_API ImGuiID ImGuiWindow_GetID_Int(ImGuiWindow* self, int n) {
  return self->GetID(n);
}
CIMGUI_API ImGuiID ImGuiWindow_GetIDFromRectangle(ImGuiWindow* self,
                                                  const ImRect r_abs) {
  return self->GetIDFromRectangle(r_abs);
}
CIMGUI_API void ImGuiWindow_Rect(ImRect* pOut, ImGuiWindow* self) {
  *pOut = self->Rect();
}
CIMGUI_API float ImGuiWindow_CalcFontSize(ImGuiWindow* self) {
  return self->CalcFontSize();
}
CIMGUI_API float ImGuiWindow_TitleBarHeight(ImGuiWindow* self) {
  return self->TitleBarHeight();
}
CIMGUI_API void ImGuiWindow_TitleBarRect(ImRect* pOut, ImGuiWindow* self) {
  *pOut = self->TitleBarRect();
}
CIMGUI_API float ImGuiWindow_MenuBarHeight(ImGuiWindow* self) {
  return self->MenuBarHeight();
}
CIMGUI_API void ImGuiWindow_MenuBarRect(ImRect* pOut, ImGuiWindow* self) {
  *pOut = self->MenuBarRect();
}
CIMGUI_API ImGuiTabItem* ImGuiTabItem_ImGuiTabItem(void) {
  return IM_NEW(ImGuiTabItem)();
}
CIMGUI_API void ImGuiTabItem_destroy(ImGuiTabItem* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiTabBar* ImGuiTabBar_ImGuiTabBar(void) {
  return IM_NEW(ImGuiTabBar)();
}
CIMGUI_API void ImGuiTabBar_destroy(ImGuiTabBar* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiTableColumn* ImGuiTableColumn_ImGuiTableColumn(void) {
  return IM_NEW(ImGuiTableColumn)();
}
CIMGUI_API void ImGuiTableColumn_destroy(ImGuiTableColumn* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiTableInstanceData*
ImGuiTableInstanceData_ImGuiTableInstanceData(void) {
  return IM_NEW(ImGuiTableInstanceData)();
}
CIMGUI_API void ImGuiTableInstanceData_destroy(ImGuiTableInstanceData* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiTable* ImGuiTable_ImGuiTable(void) {
  return IM_NEW(ImGuiTable)();
}
CIMGUI_API void ImGuiTable_destroy(ImGuiTable* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiTableTempData* ImGuiTableTempData_ImGuiTableTempData(void) {
  return IM_NEW(ImGuiTableTempData)();
}
CIMGUI_API void ImGuiTableTempData_destroy(ImGuiTableTempData* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiTableColumnSettings*
ImGuiTableColumnSettings_ImGuiTableColumnSettings(void) {
  return IM_NEW(ImGuiTableColumnSettings)();
}
CIMGUI_API void ImGuiTableColumnSettings_destroy(
    ImGuiTableColumnSettings* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiTableSettings* ImGuiTableSettings_ImGuiTableSettings(void) {
  return IM_NEW(ImGuiTableSettings)();
}
CIMGUI_API void ImGuiTableSettings_destroy(ImGuiTableSettings* self) {
  IM_DELETE(self);
}
CIMGUI_API ImGuiTableColumnSettings* ImGuiTableSettings_GetColumnSettings(
    ImGuiTableSettings* self) {
  return self->GetColumnSettings();
}
CIMGUI_API ImGuiWindow* igGetCurrentWindowRead() {
  return ImGui::GetCurrentWindowRead();
}
CIMGUI_API ImGuiWindow* igGetCurrentWindow() {
  return ImGui::GetCurrentWindow();
}
CIMGUI_API ImGuiWindow* igFindWindowByID(ImGuiID id) {
  return ImGui::FindWindowByID(id);
}
CIMGUI_API ImGuiWindow* igFindWindowByName(const char* name) {
  return ImGui::FindWindowByName(name);
}
CIMGUI_API void igUpdateWindowParentAndRootLinks(ImGuiWindow* window,
                                                 ImGuiWindowFlags flags,
                                                 ImGuiWindow* parent_window) {
  return ImGui::UpdateWindowParentAndRootLinks(window, flags, parent_window);
}
CIMGUI_API void igUpdateWindowSkipRefresh(ImGuiWindow* window) {
  return ImGui::UpdateWindowSkipRefresh(window);
}
CIMGUI_API void igCalcWindowNextAutoFitSize(ImVec2* pOut, ImGuiWindow* window) {
  *pOut = ImGui::CalcWindowNextAutoFitSize(window);
}
CIMGUI_API bool igIsWindowChildOf(ImGuiWindow* window,
                                  ImGuiWindow* potential_parent,
                                  bool popup_hierarchy,
                                  bool dock_hierarchy) {
  return ImGui::IsWindowChildOf(window, potential_parent, popup_hierarchy,
                                dock_hierarchy);
}
CIMGUI_API bool igIsWindowWithinBeginStackOf(ImGuiWindow* window,
                                             ImGuiWindow* potential_parent) {
  return ImGui::IsWindowWithinBeginStackOf(window, potential_parent);
}
CIMGUI_API bool igIsWindowAbove(ImGuiWindow* potential_above,
                                ImGuiWindow* potential_below) {
  return ImGui::IsWindowAbove(potential_above, potential_below);
}
CIMGUI_API bool igIsWindowNavFocusable(ImGuiWindow* window) {
  return ImGui::IsWindowNavFocusable(window);
}
CIMGUI_API void igSetWindowPos_WindowPtr(ImGuiWindow* window,
                                         const ImVec2 pos,
                                         ImGuiCond cond) {
  return ImGui::SetWindowPos(window, pos, cond);
}
CIMGUI_API void igSetWindowSize_WindowPtr(ImGuiWindow* window,
                                          const ImVec2 size,
                                          ImGuiCond cond) {
  return ImGui::SetWindowSize(window, size, cond);
}
CIMGUI_API void igSetWindowCollapsed_WindowPtr(ImGuiWindow* window,
                                               bool collapsed,
                                               ImGuiCond cond) {
  return ImGui::SetWindowCollapsed(window, collapsed, cond);
}
CIMGUI_API void igSetWindowHitTestHole(ImGuiWindow* window,
                                       const ImVec2 pos,
                                       const ImVec2 size) {
  return ImGui::SetWindowHitTestHole(window, pos, size);
}
CIMGUI_API void igSetWindowHiddenAndSkipItemsForCurrentFrame(
    ImGuiWindow* window) {
  return ImGui::SetWindowHiddenAndSkipItemsForCurrentFrame(window);
}
CIMGUI_API void igSetWindowParentWindowForFocusRoute(
    ImGuiWindow* window,
    ImGuiWindow* parent_window) {
  return ImGui::SetWindowParentWindowForFocusRoute(window, parent_window);
}
CIMGUI_API void igWindowRectAbsToRel(ImRect* pOut,
                                     ImGuiWindow* window,
                                     const ImRect r) {
  *pOut = ImGui::WindowRectAbsToRel(window, r);
}
CIMGUI_API void igWindowRectRelToAbs(ImRect* pOut,
                                     ImGuiWindow* window,
                                     const ImRect r) {
  *pOut = ImGui::WindowRectRelToAbs(window, r);
}
CIMGUI_API void igWindowPosRelToAbs(ImVec2* pOut,
                                    ImGuiWindow* window,
                                    const ImVec2 p) {
  *pOut = ImGui::WindowPosRelToAbs(window, p);
}
CIMGUI_API void igFocusWindow(ImGuiWindow* window,
                              ImGuiFocusRequestFlags flags) {
  return ImGui::FocusWindow(window, flags);
}
CIMGUI_API void igFocusTopMostWindowUnderOne(ImGuiWindow* under_this_window,
                                             ImGuiWindow* ignore_window,
                                             ImGuiViewport* filter_viewport,
                                             ImGuiFocusRequestFlags flags) {
  return ImGui::FocusTopMostWindowUnderOne(under_this_window, ignore_window,
                                           filter_viewport, flags);
}
CIMGUI_API void igBringWindowToFocusFront(ImGuiWindow* window) {
  return ImGui::BringWindowToFocusFront(window);
}
CIMGUI_API void igBringWindowToDisplayFront(ImGuiWindow* window) {
  return ImGui::BringWindowToDisplayFront(window);
}
CIMGUI_API void igBringWindowToDisplayBack(ImGuiWindow* window) {
  return ImGui::BringWindowToDisplayBack(window);
}
CIMGUI_API void igBringWindowToDisplayBehind(ImGuiWindow* window,
                                             ImGuiWindow* above_window) {
  return ImGui::BringWindowToDisplayBehind(window, above_window);
}
CIMGUI_API int igFindWindowDisplayIndex(ImGuiWindow* window) {
  return ImGui::FindWindowDisplayIndex(window);
}
CIMGUI_API ImGuiWindow* igFindBottomMostVisibleWindowWithinBeginStack(
    ImGuiWindow* window) {
  return ImGui::FindBottomMostVisibleWindowWithinBeginStack(window);
}
CIMGUI_API void igSetNextWindowRefreshPolicy(ImGuiWindowRefreshFlags flags) {
  return ImGui::SetNextWindowRefreshPolicy(flags);
}
CIMGUI_API void igSetCurrentFont(ImFont* font) {
  return ImGui::SetCurrentFont(font);
}
CIMGUI_API ImFont* igGetDefaultFont() {
  return ImGui::GetDefaultFont();
}
CIMGUI_API ImDrawList* igGetForegroundDrawList_WindowPtr(ImGuiWindow* window) {
  return ImGui::GetForegroundDrawList(window);
}
CIMGUI_API void igAddDrawListToDrawDataEx(ImDrawData* draw_data,
                                          ImVector_ImDrawListPtr* out_list,
                                          ImDrawList* draw_list) {
  return ImGui::AddDrawListToDrawDataEx(draw_data, out_list, draw_list);
}
CIMGUI_API void igInitialize() {
  return ImGui::Initialize();
}
CIMGUI_API void igShutdown() {
  return ImGui::Shutdown();
}
CIMGUI_API void igUpdateInputEvents(bool trickle_fast_inputs) {
  return ImGui::UpdateInputEvents(trickle_fast_inputs);
}
CIMGUI_API void igUpdateHoveredWindowAndCaptureFlags() {
  return ImGui::UpdateHoveredWindowAndCaptureFlags();
}
CIMGUI_API void igStartMouseMovingWindow(ImGuiWindow* window) {
  return ImGui::StartMouseMovingWindow(window);
}
CIMGUI_API void igStartMouseMovingWindowOrNode(ImGuiWindow* window,
                                               ImGuiDockNode* node,
                                               bool undock) {
  return ImGui::StartMouseMovingWindowOrNode(window, node, undock);
}
CIMGUI_API void igUpdateMouseMovingWindowNewFrame() {
  return ImGui::UpdateMouseMovingWindowNewFrame();
}
CIMGUI_API void igUpdateMouseMovingWindowEndFrame() {
  return ImGui::UpdateMouseMovingWindowEndFrame();
}
CIMGUI_API ImGuiID igAddContextHook(ImGuiContext* context,
                                    const ImGuiContextHook* hook) {
  return ImGui::AddContextHook(context, hook);
}
CIMGUI_API void igRemoveContextHook(ImGuiContext* context,
                                    ImGuiID hook_to_remove) {
  return ImGui::RemoveContextHook(context, hook_to_remove);
}
CIMGUI_API void igCallContextHooks(ImGuiContext* context,
                                   ImGuiContextHookType type) {
  return ImGui::CallContextHooks(context, type);
}
CIMGUI_API void igTranslateWindowsInViewport(ImGuiViewportP* viewport,
                                             const ImVec2 old_pos,
                                             const ImVec2 new_pos) {
  return ImGui::TranslateWindowsInViewport(viewport, old_pos, new_pos);
}
CIMGUI_API void igScaleWindowsInViewport(ImGuiViewportP* viewport,
                                         float scale) {
  return ImGui::ScaleWindowsInViewport(viewport, scale);
}
CIMGUI_API void igDestroyPlatformWindow(ImGuiViewportP* viewport) {
  return ImGui::DestroyPlatformWindow(viewport);
}
CIMGUI_API void igSetWindowViewport(ImGuiWindow* window,
                                    ImGuiViewportP* viewport) {
  return ImGui::SetWindowViewport(window, viewport);
}
CIMGUI_API void igSetCurrentViewport(ImGuiWindow* window,
                                     ImGuiViewportP* viewport) {
  return ImGui::SetCurrentViewport(window, viewport);
}
CIMGUI_API const ImGuiPlatformMonitor* igGetViewportPlatformMonitor(
    ImGuiViewport* viewport) {
  return ImGui::GetViewportPlatformMonitor(viewport);
}
CIMGUI_API ImGuiViewportP* igFindHoveredViewportFromPlatformWindowStack(
    const ImVec2 mouse_platform_pos) {
  return ImGui::FindHoveredViewportFromPlatformWindowStack(mouse_platform_pos);
}
CIMGUI_API void igMarkIniSettingsDirty_Nil() {
  return ImGui::MarkIniSettingsDirty();
}
CIMGUI_API void igMarkIniSettingsDirty_WindowPtr(ImGuiWindow* window) {
  return ImGui::MarkIniSettingsDirty(window);
}
CIMGUI_API void igClearIniSettings() {
  return ImGui::ClearIniSettings();
}
CIMGUI_API void igAddSettingsHandler(const ImGuiSettingsHandler* handler) {
  return ImGui::AddSettingsHandler(handler);
}
CIMGUI_API void igRemoveSettingsHandler(const char* type_name) {
  return ImGui::RemoveSettingsHandler(type_name);
}
CIMGUI_API ImGuiSettingsHandler* igFindSettingsHandler(const char* type_name) {
  return ImGui::FindSettingsHandler(type_name);
}
CIMGUI_API ImGuiWindowSettings* igCreateNewWindowSettings(const char* name) {
  return ImGui::CreateNewWindowSettings(name);
}
CIMGUI_API ImGuiWindowSettings* igFindWindowSettingsByID(ImGuiID id) {
  return ImGui::FindWindowSettingsByID(id);
}
CIMGUI_API ImGuiWindowSettings* igFindWindowSettingsByWindow(
    ImGuiWindow* window) {
  return ImGui::FindWindowSettingsByWindow(window);
}
CIMGUI_API void igClearWindowSettings(const char* name) {
  return ImGui::ClearWindowSettings(name);
}
CIMGUI_API void igLocalizeRegisterEntries(const ImGuiLocEntry* entries,
                                          int count) {
  return ImGui::LocalizeRegisterEntries(entries, count);
}
CIMGUI_API const char* igLocalizeGetMsg(ImGuiLocKey key) {
  return ImGui::LocalizeGetMsg(key);
}
CIMGUI_API void igSetScrollX_WindowPtr(ImGuiWindow* window, float scroll_x) {
  return ImGui::SetScrollX(window, scroll_x);
}
CIMGUI_API void igSetScrollY_WindowPtr(ImGuiWindow* window, float scroll_y) {
  return ImGui::SetScrollY(window, scroll_y);
}
CIMGUI_API void igSetScrollFromPosX_WindowPtr(ImGuiWindow* window,
                                              float local_x,
                                              float center_x_ratio) {
  return ImGui::SetScrollFromPosX(window, local_x, center_x_ratio);
}
CIMGUI_API void igSetScrollFromPosY_WindowPtr(ImGuiWindow* window,
                                              float local_y,
                                              float center_y_ratio) {
  return ImGui::SetScrollFromPosY(window, local_y, center_y_ratio);
}
CIMGUI_API void igScrollToItem(ImGuiScrollFlags flags) {
  return ImGui::ScrollToItem(flags);
}
CIMGUI_API void igScrollToRect(ImGuiWindow* window,
                               const ImRect rect,
                               ImGuiScrollFlags flags) {
  return ImGui::ScrollToRect(window, rect, flags);
}
CIMGUI_API void igScrollToRectEx(ImVec2* pOut,
                                 ImGuiWindow* window,
                                 const ImRect rect,
                                 ImGuiScrollFlags flags) {
  *pOut = ImGui::ScrollToRectEx(window, rect, flags);
}
CIMGUI_API void igScrollToBringRectIntoView(ImGuiWindow* window,
                                            const ImRect rect) {
  return ImGui::ScrollToBringRectIntoView(window, rect);
}
CIMGUI_API ImGuiItemStatusFlags igGetItemStatusFlags() {
  return ImGui::GetItemStatusFlags();
}
CIMGUI_API ImGuiItemFlags igGetItemFlags() {
  return ImGui::GetItemFlags();
}
CIMGUI_API ImGuiID igGetActiveID() {
  return ImGui::GetActiveID();
}
CIMGUI_API ImGuiID igGetFocusID() {
  return ImGui::GetFocusID();
}
CIMGUI_API void igSetActiveID(ImGuiID id, ImGuiWindow* window) {
  return ImGui::SetActiveID(id, window);
}
CIMGUI_API void igSetFocusID(ImGuiID id, ImGuiWindow* window) {
  return ImGui::SetFocusID(id, window);
}
CIMGUI_API void igClearActiveID() {
  return ImGui::ClearActiveID();
}
CIMGUI_API ImGuiID igGetHoveredID() {
  return ImGui::GetHoveredID();
}
CIMGUI_API void igSetHoveredID(ImGuiID id) {
  return ImGui::SetHoveredID(id);
}
CIMGUI_API void igKeepAliveID(ImGuiID id) {
  return ImGui::KeepAliveID(id);
}
CIMGUI_API void igMarkItemEdited(ImGuiID id) {
  return ImGui::MarkItemEdited(id);
}
CIMGUI_API void igPushOverrideID(ImGuiID id) {
  return ImGui::PushOverrideID(id);
}
CIMGUI_API ImGuiID igGetIDWithSeed_Str(const char* str_id_begin,
                                       const char* str_id_end,
                                       ImGuiID seed) {
  return ImGui::GetIDWithSeed(str_id_begin, str_id_end, seed);
}
CIMGUI_API ImGuiID igGetIDWithSeed_Int(int n, ImGuiID seed) {
  return ImGui::GetIDWithSeed(n, seed);
}
CIMGUI_API void igItemSize_Vec2(const ImVec2 size, float text_baseline_y) {
  return ImGui::ItemSize(size, text_baseline_y);
}
CIMGUI_API void igItemSize_Rect(const ImRect bb, float text_baseline_y) {
  return ImGui::ItemSize(bb, text_baseline_y);
}
CIMGUI_API bool igItemAdd(const ImRect bb,
                          ImGuiID id,
                          const ImRect* nav_bb,
                          ImGuiItemFlags extra_flags) {
  return ImGui::ItemAdd(bb, id, nav_bb, extra_flags);
}
CIMGUI_API bool igItemHoverable(const ImRect bb,
                                ImGuiID id,
                                ImGuiItemFlags item_flags) {
  return ImGui::ItemHoverable(bb, id, item_flags);
}
CIMGUI_API bool igIsWindowContentHoverable(ImGuiWindow* window,
                                           ImGuiHoveredFlags flags) {
  return ImGui::IsWindowContentHoverable(window, flags);
}
CIMGUI_API bool igIsClippedEx(const ImRect bb, ImGuiID id) {
  return ImGui::IsClippedEx(bb, id);
}
CIMGUI_API void igSetLastItemData(ImGuiID item_id,
                                  ImGuiItemFlags in_flags,
                                  ImGuiItemStatusFlags status_flags,
                                  const ImRect item_rect) {
  return ImGui::SetLastItemData(item_id, in_flags, status_flags, item_rect);
}
CIMGUI_API void igCalcItemSize(ImVec2* pOut,
                               ImVec2 size,
                               float default_w,
                               float default_h) {
  *pOut = ImGui::CalcItemSize(size, default_w, default_h);
}
CIMGUI_API float igCalcWrapWidthForPos(const ImVec2 pos, float wrap_pos_x) {
  return ImGui::CalcWrapWidthForPos(pos, wrap_pos_x);
}
CIMGUI_API void igPushMultiItemsWidths(int components, float width_full) {
  return ImGui::PushMultiItemsWidths(components, width_full);
}
CIMGUI_API bool igIsItemToggledSelection() {
  return ImGui::IsItemToggledSelection();
}
CIMGUI_API void igGetContentRegionMaxAbs(ImVec2* pOut) {
  *pOut = ImGui::GetContentRegionMaxAbs();
}
CIMGUI_API void igShrinkWidths(ImGuiShrinkWidthItem* items,
                               int count,
                               float width_excess) {
  return ImGui::ShrinkWidths(items, count, width_excess);
}
CIMGUI_API void igPushItemFlag(ImGuiItemFlags option, bool enabled) {
  return ImGui::PushItemFlag(option, enabled);
}
CIMGUI_API void igPopItemFlag() {
  return ImGui::PopItemFlag();
}
CIMGUI_API const ImGuiDataVarInfo* igGetStyleVarInfo(ImGuiStyleVar idx) {
  return ImGui::GetStyleVarInfo(idx);
}
CIMGUI_API void igLogBegin(ImGuiLogType type, int auto_open_depth) {
  return ImGui::LogBegin(type, auto_open_depth);
}
CIMGUI_API void igLogToBuffer(int auto_open_depth) {
  return ImGui::LogToBuffer(auto_open_depth);
}
CIMGUI_API void igLogRenderedText(const ImVec2* ref_pos,
                                  const char* text,
                                  const char* text_end) {
  return ImGui::LogRenderedText(ref_pos, text, text_end);
}
CIMGUI_API void igLogSetNextTextDecoration(const char* prefix,
                                           const char* suffix) {
  return ImGui::LogSetNextTextDecoration(prefix, suffix);
}
CIMGUI_API bool igBeginChildEx(const char* name,
                               ImGuiID id,
                               const ImVec2 size_arg,
                               ImGuiChildFlags child_flags,
                               ImGuiWindowFlags window_flags) {
  return ImGui::BeginChildEx(name, id, size_arg, child_flags, window_flags);
}
CIMGUI_API void igOpenPopupEx(ImGuiID id, ImGuiPopupFlags popup_flags) {
  return ImGui::OpenPopupEx(id, popup_flags);
}
CIMGUI_API void igClosePopupToLevel(int remaining,
                                    bool restore_focus_to_window_under_popup) {
  return ImGui::ClosePopupToLevel(remaining,
                                  restore_focus_to_window_under_popup);
}
CIMGUI_API void igClosePopupsOverWindow(
    ImGuiWindow* ref_window,
    bool restore_focus_to_window_under_popup) {
  return ImGui::ClosePopupsOverWindow(ref_window,
                                      restore_focus_to_window_under_popup);
}
CIMGUI_API void igClosePopupsExceptModals() {
  return ImGui::ClosePopupsExceptModals();
}
CIMGUI_API bool igIsPopupOpen_ID(ImGuiID id, ImGuiPopupFlags popup_flags) {
  return ImGui::IsPopupOpen(id, popup_flags);
}
CIMGUI_API bool igBeginPopupEx(ImGuiID id, ImGuiWindowFlags extra_flags) {
  return ImGui::BeginPopupEx(id, extra_flags);
}
CIMGUI_API bool igBeginTooltipEx(ImGuiTooltipFlags tooltip_flags,
                                 ImGuiWindowFlags extra_window_flags) {
  return ImGui::BeginTooltipEx(tooltip_flags, extra_window_flags);
}
CIMGUI_API bool igBeginTooltipHidden() {
  return ImGui::BeginTooltipHidden();
}
CIMGUI_API void igGetPopupAllowedExtentRect(ImRect* pOut, ImGuiWindow* window) {
  *pOut = ImGui::GetPopupAllowedExtentRect(window);
}
CIMGUI_API ImGuiWindow* igGetTopMostPopupModal() {
  return ImGui::GetTopMostPopupModal();
}
CIMGUI_API ImGuiWindow* igGetTopMostAndVisiblePopupModal() {
  return ImGui::GetTopMostAndVisiblePopupModal();
}
CIMGUI_API ImGuiWindow* igFindBlockingModal(ImGuiWindow* window) {
  return ImGui::FindBlockingModal(window);
}
CIMGUI_API void igFindBestWindowPosForPopup(ImVec2* pOut, ImGuiWindow* window) {
  *pOut = ImGui::FindBestWindowPosForPopup(window);
}
CIMGUI_API void igFindBestWindowPosForPopupEx(ImVec2* pOut,
                                              const ImVec2 ref_pos,
                                              const ImVec2 size,
                                              ImGuiDir* last_dir,
                                              const ImRect r_outer,
                                              const ImRect r_avoid,
                                              ImGuiPopupPositionPolicy policy) {
  *pOut = ImGui::FindBestWindowPosForPopupEx(ref_pos, size, last_dir, r_outer,
                                             r_avoid, policy);
}
CIMGUI_API bool igBeginViewportSideBar(const char* name,
                                       ImGuiViewport* viewport,
                                       ImGuiDir dir,
                                       float size,
                                       ImGuiWindowFlags window_flags) {
  return ImGui::BeginViewportSideBar(name, viewport, dir, size, window_flags);
}
CIMGUI_API bool igBeginMenuEx(const char* label,
                              const char* icon,
                              bool enabled) {
  return ImGui::BeginMenuEx(label, icon, enabled);
}
CIMGUI_API bool igMenuItemEx(const char* label,
                             const char* icon,
                             const char* shortcut,
                             bool selected,
                             bool enabled) {
  return ImGui::MenuItemEx(label, icon, shortcut, selected, enabled);
}
CIMGUI_API bool igBeginComboPopup(ImGuiID popup_id,
                                  const ImRect bb,
                                  ImGuiComboFlags flags) {
  return ImGui::BeginComboPopup(popup_id, bb, flags);
}
CIMGUI_API bool igBeginComboPreview() {
  return ImGui::BeginComboPreview();
}
CIMGUI_API void igEndComboPreview() {
  return ImGui::EndComboPreview();
}
CIMGUI_API void igNavInitWindow(ImGuiWindow* window, bool force_reinit) {
  return ImGui::NavInitWindow(window, force_reinit);
}
CIMGUI_API void igNavInitRequestApplyResult() {
  return ImGui::NavInitRequestApplyResult();
}
CIMGUI_API bool igNavMoveRequestButNoResultYet() {
  return ImGui::NavMoveRequestButNoResultYet();
}
CIMGUI_API void igNavMoveRequestSubmit(ImGuiDir move_dir,
                                       ImGuiDir clip_dir,
                                       ImGuiNavMoveFlags move_flags,
                                       ImGuiScrollFlags scroll_flags) {
  return ImGui::NavMoveRequestSubmit(move_dir, clip_dir, move_flags,
                                     scroll_flags);
}
CIMGUI_API void igNavMoveRequestForward(ImGuiDir move_dir,
                                        ImGuiDir clip_dir,
                                        ImGuiNavMoveFlags move_flags,
                                        ImGuiScrollFlags scroll_flags) {
  return ImGui::NavMoveRequestForward(move_dir, clip_dir, move_flags,
                                      scroll_flags);
}
CIMGUI_API void igNavMoveRequestResolveWithLastItem(ImGuiNavItemData* result) {
  return ImGui::NavMoveRequestResolveWithLastItem(result);
}
CIMGUI_API void igNavMoveRequestResolveWithPastTreeNode(
    ImGuiNavItemData* result,
    ImGuiNavTreeNodeData* tree_node_data) {
  return ImGui::NavMoveRequestResolveWithPastTreeNode(result, tree_node_data);
}
CIMGUI_API void igNavMoveRequestCancel() {
  return ImGui::NavMoveRequestCancel();
}
CIMGUI_API void igNavMoveRequestApplyResult() {
  return ImGui::NavMoveRequestApplyResult();
}
CIMGUI_API void igNavMoveRequestTryWrapping(ImGuiWindow* window,
                                            ImGuiNavMoveFlags move_flags) {
  return ImGui::NavMoveRequestTryWrapping(window, move_flags);
}
CIMGUI_API void igNavHighlightActivated(ImGuiID id) {
  return ImGui::NavHighlightActivated(id);
}
CIMGUI_API void igNavClearPreferredPosForAxis(ImGuiAxis axis) {
  return ImGui::NavClearPreferredPosForAxis(axis);
}
CIMGUI_API void igNavRestoreHighlightAfterMove() {
  return ImGui::NavRestoreHighlightAfterMove();
}
CIMGUI_API void igNavUpdateCurrentWindowIsScrollPushableX() {
  return ImGui::NavUpdateCurrentWindowIsScrollPushableX();
}
CIMGUI_API void igSetNavWindow(ImGuiWindow* window) {
  return ImGui::SetNavWindow(window);
}
CIMGUI_API void igSetNavID(ImGuiID id,
                           ImGuiNavLayer nav_layer,
                           ImGuiID focus_scope_id,
                           const ImRect rect_rel) {
  return ImGui::SetNavID(id, nav_layer, focus_scope_id, rect_rel);
}
CIMGUI_API void igSetNavFocusScope(ImGuiID focus_scope_id) {
  return ImGui::SetNavFocusScope(focus_scope_id);
}
CIMGUI_API void igFocusItem() {
  return ImGui::FocusItem();
}
CIMGUI_API void igActivateItemByID(ImGuiID id) {
  return ImGui::ActivateItemByID(id);
}
CIMGUI_API bool igIsNamedKey(ImGuiKey key) {
  return ImGui::IsNamedKey(key);
}
CIMGUI_API bool igIsNamedKeyOrModKey(ImGuiKey key) {
  return ImGui::IsNamedKeyOrModKey(key);
}
CIMGUI_API bool igIsLegacyKey(ImGuiKey key) {
  return ImGui::IsLegacyKey(key);
}
CIMGUI_API bool igIsKeyboardKey(ImGuiKey key) {
  return ImGui::IsKeyboardKey(key);
}
CIMGUI_API bool igIsGamepadKey(ImGuiKey key) {
  return ImGui::IsGamepadKey(key);
}
CIMGUI_API bool igIsMouseKey(ImGuiKey key) {
  return ImGui::IsMouseKey(key);
}
CIMGUI_API bool igIsAliasKey(ImGuiKey key) {
  return ImGui::IsAliasKey(key);
}
CIMGUI_API bool igIsModKey(ImGuiKey key) {
  return ImGui::IsModKey(key);
}
CIMGUI_API ImGuiKeyChord igFixupKeyChord(ImGuiContext* ctx,
                                         ImGuiKeyChord key_chord) {
  return ImGui::FixupKeyChord(ctx, key_chord);
}
CIMGUI_API ImGuiKey igConvertSingleModFlagToKey(ImGuiContext* ctx,
                                                ImGuiKey key) {
  return ImGui::ConvertSingleModFlagToKey(ctx, key);
}
CIMGUI_API ImGuiKeyData* igGetKeyData_ContextPtr(ImGuiContext* ctx,
                                                 ImGuiKey key) {
  return ImGui::GetKeyData(ctx, key);
}
CIMGUI_API ImGuiKeyData* igGetKeyData_Key(ImGuiKey key) {
  return ImGui::GetKeyData(key);
}
CIMGUI_API const char* igGetKeyChordName(ImGuiKeyChord key_chord) {
  return ImGui::GetKeyChordName(key_chord);
}
CIMGUI_API ImGuiKey igMouseButtonToKey(ImGuiMouseButton button) {
  return ImGui::MouseButtonToKey(button);
}
CIMGUI_API bool igIsMouseDragPastThreshold(ImGuiMouseButton button,
                                           float lock_threshold) {
  return ImGui::IsMouseDragPastThreshold(button, lock_threshold);
}
CIMGUI_API void igGetKeyMagnitude2d(ImVec2* pOut,
                                    ImGuiKey key_left,
                                    ImGuiKey key_right,
                                    ImGuiKey key_up,
                                    ImGuiKey key_down) {
  *pOut = ImGui::GetKeyMagnitude2d(key_left, key_right, key_up, key_down);
}
CIMGUI_API float igGetNavTweakPressedAmount(ImGuiAxis axis) {
  return ImGui::GetNavTweakPressedAmount(axis);
}
CIMGUI_API int igCalcTypematicRepeatAmount(float t0,
                                           float t1,
                                           float repeat_delay,
                                           float repeat_rate) {
  return ImGui::CalcTypematicRepeatAmount(t0, t1, repeat_delay, repeat_rate);
}
CIMGUI_API void igGetTypematicRepeatRate(ImGuiInputFlags flags,
                                         float* repeat_delay,
                                         float* repeat_rate) {
  return ImGui::GetTypematicRepeatRate(flags, repeat_delay, repeat_rate);
}
CIMGUI_API void igTeleportMousePos(const ImVec2 pos) {
  return ImGui::TeleportMousePos(pos);
}
CIMGUI_API void igSetActiveIdUsingAllKeyboardKeys() {
  return ImGui::SetActiveIdUsingAllKeyboardKeys();
}
CIMGUI_API bool igIsActiveIdUsingNavDir(ImGuiDir dir) {
  return ImGui::IsActiveIdUsingNavDir(dir);
}
CIMGUI_API ImGuiID igGetKeyOwner(ImGuiKey key) {
  return ImGui::GetKeyOwner(key);
}
CIMGUI_API void igSetKeyOwner(ImGuiKey key,
                              ImGuiID owner_id,
                              ImGuiInputFlags flags) {
  return ImGui::SetKeyOwner(key, owner_id, flags);
}
CIMGUI_API void igSetKeyOwnersForKeyChord(ImGuiKeyChord key,
                                          ImGuiID owner_id,
                                          ImGuiInputFlags flags) {
  return ImGui::SetKeyOwnersForKeyChord(key, owner_id, flags);
}
CIMGUI_API void igSetItemKeyOwner(ImGuiKey key, ImGuiInputFlags flags) {
  return ImGui::SetItemKeyOwner(key, flags);
}
CIMGUI_API bool igTestKeyOwner(ImGuiKey key, ImGuiID owner_id) {
  return ImGui::TestKeyOwner(key, owner_id);
}
CIMGUI_API ImGuiKeyOwnerData* igGetKeyOwnerData(ImGuiContext* ctx,
                                                ImGuiKey key) {
  return ImGui::GetKeyOwnerData(ctx, key);
}
CIMGUI_API bool igIsKeyDown_ID(ImGuiKey key, ImGuiID owner_id) {
  return ImGui::IsKeyDown(key, owner_id);
}
CIMGUI_API bool igIsKeyPressed_ID(ImGuiKey key,
                                  ImGuiID owner_id,
                                  ImGuiInputFlags flags) {
  return ImGui::IsKeyPressed(key, owner_id, flags);
}
CIMGUI_API bool igIsKeyReleased_ID(ImGuiKey key, ImGuiID owner_id) {
  return ImGui::IsKeyReleased(key, owner_id);
}
CIMGUI_API bool igIsMouseDown_ID(ImGuiMouseButton button, ImGuiID owner_id) {
  return ImGui::IsMouseDown(button, owner_id);
}
CIMGUI_API bool igIsMouseClicked_ID(ImGuiMouseButton button,
                                    ImGuiID owner_id,
                                    ImGuiInputFlags flags) {
  return ImGui::IsMouseClicked(button, owner_id, flags);
}
CIMGUI_API bool igIsMouseReleased_ID(ImGuiMouseButton button,
                                     ImGuiID owner_id) {
  return ImGui::IsMouseReleased(button, owner_id);
}
CIMGUI_API bool igIsMouseDoubleClicked_ID(ImGuiMouseButton button,
                                          ImGuiID owner_id) {
  return ImGui::IsMouseDoubleClicked(button, owner_id);
}
CIMGUI_API bool igIsKeyChordPressed_ID(ImGuiKeyChord key_chord,
                                       ImGuiID owner_id,
                                       ImGuiInputFlags flags) {
  return ImGui::IsKeyChordPressed(key_chord, owner_id, flags);
}
CIMGUI_API void igSetNextItemShortcut(ImGuiKeyChord key_chord) {
  return ImGui::SetNextItemShortcut(key_chord);
}
CIMGUI_API bool igShortcut(ImGuiKeyChord key_chord,
                           ImGuiID owner_id,
                           ImGuiInputFlags flags) {
  return ImGui::Shortcut(key_chord, owner_id, flags);
}
CIMGUI_API bool igSetShortcutRouting(ImGuiKeyChord key_chord,
                                     ImGuiID owner_id,
                                     ImGuiInputFlags flags) {
  return ImGui::SetShortcutRouting(key_chord, owner_id, flags);
}
CIMGUI_API bool igTestShortcutRouting(ImGuiKeyChord key_chord,
                                      ImGuiID owner_id) {
  return ImGui::TestShortcutRouting(key_chord, owner_id);
}
CIMGUI_API ImGuiKeyRoutingData* igGetShortcutRoutingData(
    ImGuiKeyChord key_chord) {
  return ImGui::GetShortcutRoutingData(key_chord);
}
CIMGUI_API void igDockContextInitialize(ImGuiContext* ctx) {
  return ImGui::DockContextInitialize(ctx);
}
CIMGUI_API void igDockContextShutdown(ImGuiContext* ctx) {
  return ImGui::DockContextShutdown(ctx);
}
CIMGUI_API void igDockContextClearNodes(ImGuiContext* ctx,
                                        ImGuiID root_id,
                                        bool clear_settings_refs) {
  return ImGui::DockContextClearNodes(ctx, root_id, clear_settings_refs);
}
CIMGUI_API void igDockContextRebuildNodes(ImGuiContext* ctx) {
  return ImGui::DockContextRebuildNodes(ctx);
}
CIMGUI_API void igDockContextNewFrameUpdateUndocking(ImGuiContext* ctx) {
  return ImGui::DockContextNewFrameUpdateUndocking(ctx);
}
CIMGUI_API void igDockContextNewFrameUpdateDocking(ImGuiContext* ctx) {
  return ImGui::DockContextNewFrameUpdateDocking(ctx);
}
CIMGUI_API void igDockContextEndFrame(ImGuiContext* ctx) {
  return ImGui::DockContextEndFrame(ctx);
}
CIMGUI_API ImGuiID igDockContextGenNodeID(ImGuiContext* ctx) {
  return ImGui::DockContextGenNodeID(ctx);
}
CIMGUI_API void igDockContextQueueDock(ImGuiContext* ctx,
                                       ImGuiWindow* target,
                                       ImGuiDockNode* target_node,
                                       ImGuiWindow* payload,
                                       ImGuiDir split_dir,
                                       float split_ratio,
                                       bool split_outer) {
  return ImGui::DockContextQueueDock(ctx, target, target_node, payload,
                                     split_dir, split_ratio, split_outer);
}
CIMGUI_API void igDockContextQueueUndockWindow(ImGuiContext* ctx,
                                               ImGuiWindow* window) {
  return ImGui::DockContextQueueUndockWindow(ctx, window);
}
CIMGUI_API void igDockContextQueueUndockNode(ImGuiContext* ctx,
                                             ImGuiDockNode* node) {
  return ImGui::DockContextQueueUndockNode(ctx, node);
}
CIMGUI_API void igDockContextProcessUndockWindow(
    ImGuiContext* ctx,
    ImGuiWindow* window,
    bool clear_persistent_docking_ref) {
  return ImGui::DockContextProcessUndockWindow(ctx, window,
                                               clear_persistent_docking_ref);
}
CIMGUI_API void igDockContextProcessUndockNode(ImGuiContext* ctx,
                                               ImGuiDockNode* node) {
  return ImGui::DockContextProcessUndockNode(ctx, node);
}
CIMGUI_API bool igDockContextCalcDropPosForDocking(ImGuiWindow* target,
                                                   ImGuiDockNode* target_node,
                                                   ImGuiWindow* payload_window,
                                                   ImGuiDockNode* payload_node,
                                                   ImGuiDir split_dir,
                                                   bool split_outer,
                                                   ImVec2* out_pos) {
  return ImGui::DockContextCalcDropPosForDocking(
      target, target_node, payload_window, payload_node, split_dir, split_outer,
      out_pos);
}
CIMGUI_API ImGuiDockNode* igDockContextFindNodeByID(ImGuiContext* ctx,
                                                    ImGuiID id) {
  return ImGui::DockContextFindNodeByID(ctx, id);
}
CIMGUI_API void igDockNodeWindowMenuHandler_Default(ImGuiContext* ctx,
                                                    ImGuiDockNode* node,
                                                    ImGuiTabBar* tab_bar) {
  return ImGui::DockNodeWindowMenuHandler_Default(ctx, node, tab_bar);
}
CIMGUI_API bool igDockNodeBeginAmendTabBar(ImGuiDockNode* node) {
  return ImGui::DockNodeBeginAmendTabBar(node);
}
CIMGUI_API void igDockNodeEndAmendTabBar() {
  return ImGui::DockNodeEndAmendTabBar();
}
CIMGUI_API ImGuiDockNode* igDockNodeGetRootNode(ImGuiDockNode* node) {
  return ImGui::DockNodeGetRootNode(node);
}
CIMGUI_API bool igDockNodeIsInHierarchyOf(ImGuiDockNode* node,
                                          ImGuiDockNode* parent) {
  return ImGui::DockNodeIsInHierarchyOf(node, parent);
}
CIMGUI_API int igDockNodeGetDepth(const ImGuiDockNode* node) {
  return ImGui::DockNodeGetDepth(node);
}
CIMGUI_API ImGuiID igDockNodeGetWindowMenuButtonId(const ImGuiDockNode* node) {
  return ImGui::DockNodeGetWindowMenuButtonId(node);
}
CIMGUI_API ImGuiDockNode* igGetWindowDockNode() {
  return ImGui::GetWindowDockNode();
}
CIMGUI_API bool igGetWindowAlwaysWantOwnTabBar(ImGuiWindow* window) {
  return ImGui::GetWindowAlwaysWantOwnTabBar(window);
}
CIMGUI_API void igBeginDocked(ImGuiWindow* window, bool* p_open) {
  return ImGui::BeginDocked(window, p_open);
}
CIMGUI_API void igBeginDockableDragDropSource(ImGuiWindow* window) {
  return ImGui::BeginDockableDragDropSource(window);
}
CIMGUI_API void igBeginDockableDragDropTarget(ImGuiWindow* window) {
  return ImGui::BeginDockableDragDropTarget(window);
}
CIMGUI_API void igSetWindowDock(ImGuiWindow* window,
                                ImGuiID dock_id,
                                ImGuiCond cond) {
  return ImGui::SetWindowDock(window, dock_id, cond);
}
CIMGUI_API void igDockBuilderDockWindow(const char* window_name,
                                        ImGuiID node_id) {
  return ImGui::DockBuilderDockWindow(window_name, node_id);
}
CIMGUI_API ImGuiDockNode* igDockBuilderGetNode(ImGuiID node_id) {
  return ImGui::DockBuilderGetNode(node_id);
}
CIMGUI_API ImGuiDockNode* igDockBuilderGetCentralNode(ImGuiID node_id) {
  return ImGui::DockBuilderGetCentralNode(node_id);
}
CIMGUI_API ImGuiID igDockBuilderAddNode(ImGuiID node_id,
                                        ImGuiDockNodeFlags flags) {
  return ImGui::DockBuilderAddNode(node_id, flags);
}
CIMGUI_API void igDockBuilderRemoveNode(ImGuiID node_id) {
  return ImGui::DockBuilderRemoveNode(node_id);
}
CIMGUI_API void igDockBuilderRemoveNodeDockedWindows(ImGuiID node_id,
                                                     bool clear_settings_refs) {
  return ImGui::DockBuilderRemoveNodeDockedWindows(node_id,
                                                   clear_settings_refs);
}
CIMGUI_API void igDockBuilderRemoveNodeChildNodes(ImGuiID node_id) {
  return ImGui::DockBuilderRemoveNodeChildNodes(node_id);
}
CIMGUI_API void igDockBuilderSetNodePos(ImGuiID node_id, ImVec2 pos) {
  return ImGui::DockBuilderSetNodePos(node_id, pos);
}
CIMGUI_API void igDockBuilderSetNodeSize(ImGuiID node_id, ImVec2 size) {
  return ImGui::DockBuilderSetNodeSize(node_id, size);
}
CIMGUI_API ImGuiID igDockBuilderSplitNode(ImGuiID node_id,
                                          ImGuiDir split_dir,
                                          float size_ratio_for_node_at_dir,
                                          ImGuiID* out_id_at_dir,
                                          ImGuiID* out_id_at_opposite_dir) {
  return ImGui::DockBuilderSplitNode(node_id, split_dir,
                                     size_ratio_for_node_at_dir, out_id_at_dir,
                                     out_id_at_opposite_dir);
}
CIMGUI_API void igDockBuilderCopyDockSpace(
    ImGuiID src_dockspace_id,
    ImGuiID dst_dockspace_id,
    ImVector_const_charPtr* in_window_remap_pairs) {
  return ImGui::DockBuilderCopyDockSpace(src_dockspace_id, dst_dockspace_id,
                                         in_window_remap_pairs);
}
CIMGUI_API void igDockBuilderCopyNode(ImGuiID src_node_id,
                                      ImGuiID dst_node_id,
                                      ImVector_ImGuiID* out_node_remap_pairs) {
  return ImGui::DockBuilderCopyNode(src_node_id, dst_node_id,
                                    out_node_remap_pairs);
}
CIMGUI_API void igDockBuilderCopyWindowSettings(const char* src_name,
                                                const char* dst_name) {
  return ImGui::DockBuilderCopyWindowSettings(src_name, dst_name);
}
CIMGUI_API void igDockBuilderFinish(ImGuiID node_id) {
  return ImGui::DockBuilderFinish(node_id);
}
CIMGUI_API void igPushFocusScope(ImGuiID id) {
  return ImGui::PushFocusScope(id);
}
CIMGUI_API void igPopFocusScope() {
  return ImGui::PopFocusScope();
}
CIMGUI_API ImGuiID igGetCurrentFocusScope() {
  return ImGui::GetCurrentFocusScope();
}
CIMGUI_API bool igIsDragDropActive() {
  return ImGui::IsDragDropActive();
}
CIMGUI_API bool igBeginDragDropTargetCustom(const ImRect bb, ImGuiID id) {
  return ImGui::BeginDragDropTargetCustom(bb, id);
}
CIMGUI_API void igClearDragDrop() {
  return ImGui::ClearDragDrop();
}
CIMGUI_API bool igIsDragDropPayloadBeingAccepted() {
  return ImGui::IsDragDropPayloadBeingAccepted();
}
CIMGUI_API void igRenderDragDropTargetRect(const ImRect bb,
                                           const ImRect item_clip_rect) {
  return ImGui::RenderDragDropTargetRect(bb, item_clip_rect);
}
CIMGUI_API ImGuiTypingSelectRequest* igGetTypingSelectRequest(
    ImGuiTypingSelectFlags flags) {
  return ImGui::GetTypingSelectRequest(flags);
}
CIMGUI_API int igTypingSelectFindMatch(ImGuiTypingSelectRequest* req,
                                       int items_count,
                                       const char* (*get_item_name_func)(void*,
                                                                         int),
                                       void* user_data,
                                       int nav_item_idx) {
  return ImGui::TypingSelectFindMatch(req, items_count, get_item_name_func,
                                      user_data, nav_item_idx);
}
CIMGUI_API int igTypingSelectFindNextSingleCharMatch(
    ImGuiTypingSelectRequest* req,
    int items_count,
    const char* (*get_item_name_func)(void*, int),
    void* user_data,
    int nav_item_idx) {
  return ImGui::TypingSelectFindNextSingleCharMatch(
      req, items_count, get_item_name_func, user_data, nav_item_idx);
}
CIMGUI_API int igTypingSelectFindBestLeadingMatch(
    ImGuiTypingSelectRequest* req,
    int items_count,
    const char* (*get_item_name_func)(void*, int),
    void* user_data) {
  return ImGui::TypingSelectFindBestLeadingMatch(req, items_count,
                                                 get_item_name_func, user_data);
}
CIMGUI_API void igSetWindowClipRectBeforeSetChannel(ImGuiWindow* window,
                                                    const ImRect clip_rect) {
  return ImGui::SetWindowClipRectBeforeSetChannel(window, clip_rect);
}
CIMGUI_API void igBeginColumns(const char* str_id,
                               int count,
                               ImGuiOldColumnFlags flags) {
  return ImGui::BeginColumns(str_id, count, flags);
}
CIMGUI_API void igEndColumns() {
  return ImGui::EndColumns();
}
CIMGUI_API void igPushColumnClipRect(int column_index) {
  return ImGui::PushColumnClipRect(column_index);
}
CIMGUI_API void igPushColumnsBackground() {
  return ImGui::PushColumnsBackground();
}
CIMGUI_API void igPopColumnsBackground() {
  return ImGui::PopColumnsBackground();
}
CIMGUI_API ImGuiID igGetColumnsID(const char* str_id, int count) {
  return ImGui::GetColumnsID(str_id, count);
}
CIMGUI_API ImGuiOldColumns* igFindOrCreateColumns(ImGuiWindow* window,
                                                  ImGuiID id) {
  return ImGui::FindOrCreateColumns(window, id);
}
CIMGUI_API float igGetColumnOffsetFromNorm(const ImGuiOldColumns* columns,
                                           float offset_norm) {
  return ImGui::GetColumnOffsetFromNorm(columns, offset_norm);
}
CIMGUI_API float igGetColumnNormFromOffset(const ImGuiOldColumns* columns,
                                           float offset) {
  return ImGui::GetColumnNormFromOffset(columns, offset);
}
CIMGUI_API void igTableOpenContextMenu(int column_n) {
  return ImGui::TableOpenContextMenu(column_n);
}
CIMGUI_API void igTableSetColumnWidth(int column_n, float width) {
  return ImGui::TableSetColumnWidth(column_n, width);
}
CIMGUI_API void igTableSetColumnSortDirection(int column_n,
                                              ImGuiSortDirection sort_direction,
                                              bool append_to_sort_specs) {
  return ImGui::TableSetColumnSortDirection(column_n, sort_direction,
                                            append_to_sort_specs);
}
CIMGUI_API int igTableGetHoveredColumn() {
  return ImGui::TableGetHoveredColumn();
}
CIMGUI_API int igTableGetHoveredRow() {
  return ImGui::TableGetHoveredRow();
}
CIMGUI_API float igTableGetHeaderRowHeight() {
  return ImGui::TableGetHeaderRowHeight();
}
CIMGUI_API float igTableGetHeaderAngledMaxLabelWidth() {
  return ImGui::TableGetHeaderAngledMaxLabelWidth();
}
CIMGUI_API void igTablePushBackgroundChannel() {
  return ImGui::TablePushBackgroundChannel();
}
CIMGUI_API void igTablePopBackgroundChannel() {
  return ImGui::TablePopBackgroundChannel();
}
CIMGUI_API void igTableAngledHeadersRowEx(ImGuiID row_id,
                                          float angle,
                                          float max_label_width,
                                          const ImGuiTableHeaderData* data,
                                          int data_count) {
  return ImGui::TableAngledHeadersRowEx(row_id, angle, max_label_width, data,
                                        data_count);
}
CIMGUI_API ImGuiTable* igGetCurrentTable() {
  return ImGui::GetCurrentTable();
}
CIMGUI_API ImGuiTable* igTableFindByID(ImGuiID id) {
  return ImGui::TableFindByID(id);
}
CIMGUI_API bool igBeginTableEx(const char* name,
                               ImGuiID id,
                               int columns_count,
                               ImGuiTableFlags flags,
                               const ImVec2 outer_size,
                               float inner_width) {
  return ImGui::BeginTableEx(name, id, columns_count, flags, outer_size,
                             inner_width);
}
CIMGUI_API void igTableBeginInitMemory(ImGuiTable* table, int columns_count) {
  return ImGui::TableBeginInitMemory(table, columns_count);
}
CIMGUI_API void igTableBeginApplyRequests(ImGuiTable* table) {
  return ImGui::TableBeginApplyRequests(table);
}
CIMGUI_API void igTableSetupDrawChannels(ImGuiTable* table) {
  return ImGui::TableSetupDrawChannels(table);
}
CIMGUI_API void igTableUpdateLayout(ImGuiTable* table) {
  return ImGui::TableUpdateLayout(table);
}
CIMGUI_API void igTableUpdateBorders(ImGuiTable* table) {
  return ImGui::TableUpdateBorders(table);
}
CIMGUI_API void igTableUpdateColumnsWeightFromWidth(ImGuiTable* table) {
  return ImGui::TableUpdateColumnsWeightFromWidth(table);
}
CIMGUI_API void igTableDrawBorders(ImGuiTable* table) {
  return ImGui::TableDrawBorders(table);
}
CIMGUI_API void igTableDrawDefaultContextMenu(
    ImGuiTable* table,
    ImGuiTableFlags flags_for_section_to_display) {
  return ImGui::TableDrawDefaultContextMenu(table,
                                            flags_for_section_to_display);
}
CIMGUI_API bool igTableBeginContextMenuPopup(ImGuiTable* table) {
  return ImGui::TableBeginContextMenuPopup(table);
}
CIMGUI_API void igTableMergeDrawChannels(ImGuiTable* table) {
  return ImGui::TableMergeDrawChannels(table);
}
CIMGUI_API ImGuiTableInstanceData* igTableGetInstanceData(ImGuiTable* table,
                                                          int instance_no) {
  return ImGui::TableGetInstanceData(table, instance_no);
}
CIMGUI_API ImGuiID igTableGetInstanceID(ImGuiTable* table, int instance_no) {
  return ImGui::TableGetInstanceID(table, instance_no);
}
CIMGUI_API void igTableSortSpecsSanitize(ImGuiTable* table) {
  return ImGui::TableSortSpecsSanitize(table);
}
CIMGUI_API void igTableSortSpecsBuild(ImGuiTable* table) {
  return ImGui::TableSortSpecsBuild(table);
}
CIMGUI_API ImGuiSortDirection
igTableGetColumnNextSortDirection(ImGuiTableColumn* column) {
  return ImGui::TableGetColumnNextSortDirection(column);
}
CIMGUI_API void igTableFixColumnSortDirection(ImGuiTable* table,
                                              ImGuiTableColumn* column) {
  return ImGui::TableFixColumnSortDirection(table, column);
}
CIMGUI_API float igTableGetColumnWidthAuto(ImGuiTable* table,
                                           ImGuiTableColumn* column) {
  return ImGui::TableGetColumnWidthAuto(table, column);
}
CIMGUI_API void igTableBeginRow(ImGuiTable* table) {
  return ImGui::TableBeginRow(table);
}
CIMGUI_API void igTableEndRow(ImGuiTable* table) {
  return ImGui::TableEndRow(table);
}
CIMGUI_API void igTableBeginCell(ImGuiTable* table, int column_n) {
  return ImGui::TableBeginCell(table, column_n);
}
CIMGUI_API void igTableEndCell(ImGuiTable* table) {
  return ImGui::TableEndCell(table);
}
CIMGUI_API void igTableGetCellBgRect(ImRect* pOut,
                                     const ImGuiTable* table,
                                     int column_n) {
  *pOut = ImGui::TableGetCellBgRect(table, column_n);
}
CIMGUI_API const char* igTableGetColumnName_TablePtr(const ImGuiTable* table,
                                                     int column_n) {
  return ImGui::TableGetColumnName(table, column_n);
}
CIMGUI_API ImGuiID igTableGetColumnResizeID(ImGuiTable* table,
                                            int column_n,
                                            int instance_no) {
  return ImGui::TableGetColumnResizeID(table, column_n, instance_no);
}
CIMGUI_API float igTableGetMaxColumnWidth(const ImGuiTable* table,
                                          int column_n) {
  return ImGui::TableGetMaxColumnWidth(table, column_n);
}
CIMGUI_API void igTableSetColumnWidthAutoSingle(ImGuiTable* table,
                                                int column_n) {
  return ImGui::TableSetColumnWidthAutoSingle(table, column_n);
}
CIMGUI_API void igTableSetColumnWidthAutoAll(ImGuiTable* table) {
  return ImGui::TableSetColumnWidthAutoAll(table);
}
CIMGUI_API void igTableRemove(ImGuiTable* table) {
  return ImGui::TableRemove(table);
}
CIMGUI_API void igTableGcCompactTransientBuffers_TablePtr(ImGuiTable* table) {
  return ImGui::TableGcCompactTransientBuffers(table);
}
CIMGUI_API void igTableGcCompactTransientBuffers_TableTempDataPtr(
    ImGuiTableTempData* table) {
  return ImGui::TableGcCompactTransientBuffers(table);
}
CIMGUI_API void igTableGcCompactSettings() {
  return ImGui::TableGcCompactSettings();
}
CIMGUI_API void igTableLoadSettings(ImGuiTable* table) {
  return ImGui::TableLoadSettings(table);
}
CIMGUI_API void igTableSaveSettings(ImGuiTable* table) {
  return ImGui::TableSaveSettings(table);
}
CIMGUI_API void igTableResetSettings(ImGuiTable* table) {
  return ImGui::TableResetSettings(table);
}
CIMGUI_API ImGuiTableSettings* igTableGetBoundSettings(ImGuiTable* table) {
  return ImGui::TableGetBoundSettings(table);
}
CIMGUI_API void igTableSettingsAddSettingsHandler() {
  return ImGui::TableSettingsAddSettingsHandler();
}
CIMGUI_API ImGuiTableSettings* igTableSettingsCreate(ImGuiID id,
                                                     int columns_count) {
  return ImGui::TableSettingsCreate(id, columns_count);
}
CIMGUI_API ImGuiTableSettings* igTableSettingsFindByID(ImGuiID id) {
  return ImGui::TableSettingsFindByID(id);
}
CIMGUI_API ImGuiTabBar* igGetCurrentTabBar() {
  return ImGui::GetCurrentTabBar();
}
CIMGUI_API bool igBeginTabBarEx(ImGuiTabBar* tab_bar,
                                const ImRect bb,
                                ImGuiTabBarFlags flags) {
  return ImGui::BeginTabBarEx(tab_bar, bb, flags);
}
CIMGUI_API ImGuiTabItem* igTabBarFindTabByID(ImGuiTabBar* tab_bar,
                                             ImGuiID tab_id) {
  return ImGui::TabBarFindTabByID(tab_bar, tab_id);
}
CIMGUI_API ImGuiTabItem* igTabBarFindTabByOrder(ImGuiTabBar* tab_bar,
                                                int order) {
  return ImGui::TabBarFindTabByOrder(tab_bar, order);
}
CIMGUI_API ImGuiTabItem* igTabBarFindMostRecentlySelectedTabForActiveWindow(
    ImGuiTabBar* tab_bar) {
  return ImGui::TabBarFindMostRecentlySelectedTabForActiveWindow(tab_bar);
}
CIMGUI_API ImGuiTabItem* igTabBarGetCurrentTab(ImGuiTabBar* tab_bar) {
  return ImGui::TabBarGetCurrentTab(tab_bar);
}
CIMGUI_API int igTabBarGetTabOrder(ImGuiTabBar* tab_bar, ImGuiTabItem* tab) {
  return ImGui::TabBarGetTabOrder(tab_bar, tab);
}
CIMGUI_API const char* igTabBarGetTabName(ImGuiTabBar* tab_bar,
                                          ImGuiTabItem* tab) {
  return ImGui::TabBarGetTabName(tab_bar, tab);
}
CIMGUI_API void igTabBarAddTab(ImGuiTabBar* tab_bar,
                               ImGuiTabItemFlags tab_flags,
                               ImGuiWindow* window) {
  return ImGui::TabBarAddTab(tab_bar, tab_flags, window);
}
CIMGUI_API void igTabBarRemoveTab(ImGuiTabBar* tab_bar, ImGuiID tab_id) {
  return ImGui::TabBarRemoveTab(tab_bar, tab_id);
}
CIMGUI_API void igTabBarCloseTab(ImGuiTabBar* tab_bar, ImGuiTabItem* tab) {
  return ImGui::TabBarCloseTab(tab_bar, tab);
}
CIMGUI_API void igTabBarQueueFocus(ImGuiTabBar* tab_bar, ImGuiTabItem* tab) {
  return ImGui::TabBarQueueFocus(tab_bar, tab);
}
CIMGUI_API void igTabBarQueueReorder(ImGuiTabBar* tab_bar,
                                     ImGuiTabItem* tab,
                                     int offset) {
  return ImGui::TabBarQueueReorder(tab_bar, tab, offset);
}
CIMGUI_API void igTabBarQueueReorderFromMousePos(ImGuiTabBar* tab_bar,
                                                 ImGuiTabItem* tab,
                                                 ImVec2 mouse_pos) {
  return ImGui::TabBarQueueReorderFromMousePos(tab_bar, tab, mouse_pos);
}
CIMGUI_API bool igTabBarProcessReorder(ImGuiTabBar* tab_bar) {
  return ImGui::TabBarProcessReorder(tab_bar);
}
CIMGUI_API bool igTabItemEx(ImGuiTabBar* tab_bar,
                            const char* label,
                            bool* p_open,
                            ImGuiTabItemFlags flags,
                            ImGuiWindow* docked_window) {
  return ImGui::TabItemEx(tab_bar, label, p_open, flags, docked_window);
}
CIMGUI_API void igTabItemCalcSize_Str(ImVec2* pOut,
                                      const char* label,
                                      bool has_close_button_or_unsaved_marker) {
  *pOut = ImGui::TabItemCalcSize(label, has_close_button_or_unsaved_marker);
}
CIMGUI_API void igTabItemCalcSize_WindowPtr(ImVec2* pOut, ImGuiWindow* window) {
  *pOut = ImGui::TabItemCalcSize(window);
}
CIMGUI_API void igTabItemBackground(ImDrawList* draw_list,
                                    const ImRect bb,
                                    ImGuiTabItemFlags flags,
                                    ImU32 col) {
  return ImGui::TabItemBackground(draw_list, bb, flags, col);
}
CIMGUI_API void igTabItemLabelAndCloseButton(ImDrawList* draw_list,
                                             const ImRect bb,
                                             ImGuiTabItemFlags flags,
                                             ImVec2 frame_padding,
                                             const char* label,
                                             ImGuiID tab_id,
                                             ImGuiID close_button_id,
                                             bool is_contents_visible,
                                             bool* out_just_closed,
                                             bool* out_text_clipped) {
  return ImGui::TabItemLabelAndCloseButton(
      draw_list, bb, flags, frame_padding, label, tab_id, close_button_id,
      is_contents_visible, out_just_closed, out_text_clipped);
}
CIMGUI_API void igRenderText(ImVec2 pos,
                             const char* text,
                             const char* text_end,
                             bool hide_text_after_hash) {
  return ImGui::RenderText(pos, text, text_end, hide_text_after_hash);
}
CIMGUI_API void igRenderTextWrapped(ImVec2 pos,
                                    const char* text,
                                    const char* text_end,
                                    float wrap_width) {
  return ImGui::RenderTextWrapped(pos, text, text_end, wrap_width);
}
CIMGUI_API void igRenderTextClipped(const ImVec2 pos_min,
                                    const ImVec2 pos_max,
                                    const char* text,
                                    const char* text_end,
                                    const ImVec2* text_size_if_known,
                                    const ImVec2 align,
                                    const ImRect* clip_rect) {
  return ImGui::RenderTextClipped(pos_min, pos_max, text, text_end,
                                  text_size_if_known, align, clip_rect);
}
CIMGUI_API void igRenderTextClippedEx(ImDrawList* draw_list,
                                      const ImVec2 pos_min,
                                      const ImVec2 pos_max,
                                      const char* text,
                                      const char* text_end,
                                      const ImVec2* text_size_if_known,
                                      const ImVec2 align,
                                      const ImRect* clip_rect) {
  return ImGui::RenderTextClippedEx(draw_list, pos_min, pos_max, text, text_end,
                                    text_size_if_known, align, clip_rect);
}
CIMGUI_API void igRenderTextEllipsis(ImDrawList* draw_list,
                                     const ImVec2 pos_min,
                                     const ImVec2 pos_max,
                                     float clip_max_x,
                                     float ellipsis_max_x,
                                     const char* text,
                                     const char* text_end,
                                     const ImVec2* text_size_if_known) {
  return ImGui::RenderTextEllipsis(draw_list, pos_min, pos_max, clip_max_x,
                                   ellipsis_max_x, text, text_end,
                                   text_size_if_known);
}
CIMGUI_API void igRenderFrame(ImVec2 p_min,
                              ImVec2 p_max,
                              ImU32 fill_col,
                              bool border,
                              float rounding) {
  return ImGui::RenderFrame(p_min, p_max, fill_col, border, rounding);
}
CIMGUI_API void igRenderFrameBorder(ImVec2 p_min,
                                    ImVec2 p_max,
                                    float rounding) {
  return ImGui::RenderFrameBorder(p_min, p_max, rounding);
}
CIMGUI_API void igRenderColorRectWithAlphaCheckerboard(ImDrawList* draw_list,
                                                       ImVec2 p_min,
                                                       ImVec2 p_max,
                                                       ImU32 fill_col,
                                                       float grid_step,
                                                       ImVec2 grid_off,
                                                       float rounding,
                                                       ImDrawFlags flags) {
  return ImGui::RenderColorRectWithAlphaCheckerboard(
      draw_list, p_min, p_max, fill_col, grid_step, grid_off, rounding, flags);
}
CIMGUI_API void igRenderNavHighlight(const ImRect bb,
                                     ImGuiID id,
                                     ImGuiNavHighlightFlags flags) {
  return ImGui::RenderNavHighlight(bb, id, flags);
}
CIMGUI_API const char* igFindRenderedTextEnd(const char* text,
                                             const char* text_end) {
  return ImGui::FindRenderedTextEnd(text, text_end);
}
CIMGUI_API void igRenderMouseCursor(ImVec2 pos,
                                    float scale,
                                    ImGuiMouseCursor mouse_cursor,
                                    ImU32 col_fill,
                                    ImU32 col_border,
                                    ImU32 col_shadow) {
  return ImGui::RenderMouseCursor(pos, scale, mouse_cursor, col_fill,
                                  col_border, col_shadow);
}
CIMGUI_API void igRenderArrow(ImDrawList* draw_list,
                              ImVec2 pos,
                              ImU32 col,
                              ImGuiDir dir,
                              float scale) {
  return ImGui::RenderArrow(draw_list, pos, col, dir, scale);
}
CIMGUI_API void igRenderBullet(ImDrawList* draw_list, ImVec2 pos, ImU32 col) {
  return ImGui::RenderBullet(draw_list, pos, col);
}
CIMGUI_API void igRenderCheckMark(ImDrawList* draw_list,
                                  ImVec2 pos,
                                  ImU32 col,
                                  float sz) {
  return ImGui::RenderCheckMark(draw_list, pos, col, sz);
}
CIMGUI_API void igRenderArrowPointingAt(ImDrawList* draw_list,
                                        ImVec2 pos,
                                        ImVec2 half_sz,
                                        ImGuiDir direction,
                                        ImU32 col) {
  return ImGui::RenderArrowPointingAt(draw_list, pos, half_sz, direction, col);
}
CIMGUI_API void igRenderArrowDockMenu(ImDrawList* draw_list,
                                      ImVec2 p_min,
                                      float sz,
                                      ImU32 col) {
  return ImGui::RenderArrowDockMenu(draw_list, p_min, sz, col);
}
CIMGUI_API void igRenderRectFilledRangeH(ImDrawList* draw_list,
                                         const ImRect rect,
                                         ImU32 col,
                                         float x_start_norm,
                                         float x_end_norm,
                                         float rounding) {
  return ImGui::RenderRectFilledRangeH(draw_list, rect, col, x_start_norm,
                                       x_end_norm, rounding);
}
CIMGUI_API void igRenderRectFilledWithHole(ImDrawList* draw_list,
                                           const ImRect outer,
                                           const ImRect inner,
                                           ImU32 col,
                                           float rounding) {
  return ImGui::RenderRectFilledWithHole(draw_list, outer, inner, col,
                                         rounding);
}
CIMGUI_API ImDrawFlags igCalcRoundingFlagsForRectInRect(const ImRect r_in,
                                                        const ImRect r_outer,
                                                        float threshold) {
  return ImGui::CalcRoundingFlagsForRectInRect(r_in, r_outer, threshold);
}
CIMGUI_API void igTextEx(const char* text,
                         const char* text_end,
                         ImGuiTextFlags flags) {
  return ImGui::TextEx(text, text_end, flags);
}
CIMGUI_API bool igButtonEx(const char* label,
                           const ImVec2 size_arg,
                           ImGuiButtonFlags flags) {
  return ImGui::ButtonEx(label, size_arg, flags);
}
CIMGUI_API bool igArrowButtonEx(const char* str_id,
                                ImGuiDir dir,
                                ImVec2 size_arg,
                                ImGuiButtonFlags flags) {
  return ImGui::ArrowButtonEx(str_id, dir, size_arg, flags);
}
CIMGUI_API bool igImageButtonEx(ImGuiID id,
                                ImTextureID texture_id,
                                const ImVec2 image_size,
                                const ImVec2 uv0,
                                const ImVec2 uv1,
                                const ImVec4 bg_col,
                                const ImVec4 tint_col,
                                ImGuiButtonFlags flags) {
  return ImGui::ImageButtonEx(id, texture_id, image_size, uv0, uv1, bg_col,
                              tint_col, flags);
}
CIMGUI_API void igSeparatorEx(ImGuiSeparatorFlags flags, float thickness) {
  return ImGui::SeparatorEx(flags, thickness);
}
CIMGUI_API void igSeparatorTextEx(ImGuiID id,
                                  const char* label,
                                  const char* label_end,
                                  float extra_width) {
  return ImGui::SeparatorTextEx(id, label, label_end, extra_width);
}
CIMGUI_API bool igCheckboxFlags_S64Ptr(const char* label,
                                       ImS64* flags,
                                       ImS64 flags_value) {
  return ImGui::CheckboxFlags(label, flags, flags_value);
}
CIMGUI_API bool igCheckboxFlags_U64Ptr(const char* label,
                                       ImU64* flags,
                                       ImU64 flags_value) {
  return ImGui::CheckboxFlags(label, flags, flags_value);
}
CIMGUI_API bool igCloseButton(ImGuiID id, const ImVec2 pos) {
  return ImGui::CloseButton(id, pos);
}
CIMGUI_API bool igCollapseButton(ImGuiID id,
                                 const ImVec2 pos,
                                 ImGuiDockNode* dock_node) {
  return ImGui::CollapseButton(id, pos, dock_node);
}
CIMGUI_API void igScrollbar(ImGuiAxis axis) {
  return ImGui::Scrollbar(axis);
}
CIMGUI_API bool igScrollbarEx(const ImRect bb,
                              ImGuiID id,
                              ImGuiAxis axis,
                              ImS64* p_scroll_v,
                              ImS64 avail_v,
                              ImS64 contents_v,
                              ImDrawFlags flags) {
  return ImGui::ScrollbarEx(bb, id, axis, p_scroll_v, avail_v, contents_v,
                            flags);
}
CIMGUI_API void igGetWindowScrollbarRect(ImRect* pOut,
                                         ImGuiWindow* window,
                                         ImGuiAxis axis) {
  *pOut = ImGui::GetWindowScrollbarRect(window, axis);
}
CIMGUI_API ImGuiID igGetWindowScrollbarID(ImGuiWindow* window, ImGuiAxis axis) {
  return ImGui::GetWindowScrollbarID(window, axis);
}
CIMGUI_API ImGuiID igGetWindowResizeCornerID(ImGuiWindow* window, int n) {
  return ImGui::GetWindowResizeCornerID(window, n);
}
CIMGUI_API ImGuiID igGetWindowResizeBorderID(ImGuiWindow* window,
                                             ImGuiDir dir) {
  return ImGui::GetWindowResizeBorderID(window, dir);
}
CIMGUI_API bool igButtonBehavior(const ImRect bb,
                                 ImGuiID id,
                                 bool* out_hovered,
                                 bool* out_held,
                                 ImGuiButtonFlags flags) {
  return ImGui::ButtonBehavior(bb, id, out_hovered, out_held, flags);
}
CIMGUI_API bool igDragBehavior(ImGuiID id,
                               ImGuiDataType data_type,
                               void* p_v,
                               float v_speed,
                               const void* p_min,
                               const void* p_max,
                               const char* format,
                               ImGuiSliderFlags flags) {
  return ImGui::DragBehavior(id, data_type, p_v, v_speed, p_min, p_max, format,
                             flags);
}
CIMGUI_API bool igSliderBehavior(const ImRect bb,
                                 ImGuiID id,
                                 ImGuiDataType data_type,
                                 void* p_v,
                                 const void* p_min,
                                 const void* p_max,
                                 const char* format,
                                 ImGuiSliderFlags flags,
                                 ImRect* out_grab_bb) {
  return ImGui::SliderBehavior(bb, id, data_type, p_v, p_min, p_max, format,
                               flags, out_grab_bb);
}
CIMGUI_API bool igSplitterBehavior(const ImRect bb,
                                   ImGuiID id,
                                   ImGuiAxis axis,
                                   float* size1,
                                   float* size2,
                                   float min_size1,
                                   float min_size2,
                                   float hover_extend,
                                   float hover_visibility_delay,
                                   ImU32 bg_col) {
  return ImGui::SplitterBehavior(bb, id, axis, size1, size2, min_size1,
                                 min_size2, hover_extend,
                                 hover_visibility_delay, bg_col);
}
CIMGUI_API bool igTreeNodeBehavior(ImGuiID id,
                                   ImGuiTreeNodeFlags flags,
                                   const char* label,
                                   const char* label_end) {
  return ImGui::TreeNodeBehavior(id, flags, label, label_end);
}
CIMGUI_API void igTreePushOverrideID(ImGuiID id) {
  return ImGui::TreePushOverrideID(id);
}
CIMGUI_API void igTreeNodeSetOpen(ImGuiID id, bool open) {
  return ImGui::TreeNodeSetOpen(id, open);
}
CIMGUI_API bool igTreeNodeUpdateNextOpen(ImGuiID id, ImGuiTreeNodeFlags flags) {
  return ImGui::TreeNodeUpdateNextOpen(id, flags);
}
CIMGUI_API void igSetNextItemSelectionUserData(
    ImGuiSelectionUserData selection_user_data) {
  return ImGui::SetNextItemSelectionUserData(selection_user_data);
}
CIMGUI_API const ImGuiDataTypeInfo* igDataTypeGetInfo(ImGuiDataType data_type) {
  return ImGui::DataTypeGetInfo(data_type);
}
CIMGUI_API int igDataTypeFormatString(char* buf,
                                      int buf_size,
                                      ImGuiDataType data_type,
                                      const void* p_data,
                                      const char* format) {
  return ImGui::DataTypeFormatString(buf, buf_size, data_type, p_data, format);
}
CIMGUI_API void igDataTypeApplyOp(ImGuiDataType data_type,
                                  int op,
                                  void* output,
                                  const void* arg_1,
                                  const void* arg_2) {
  return ImGui::DataTypeApplyOp(data_type, op, output, arg_1, arg_2);
}
CIMGUI_API bool igDataTypeApplyFromText(const char* buf,
                                        ImGuiDataType data_type,
                                        void* p_data,
                                        const char* format) {
  return ImGui::DataTypeApplyFromText(buf, data_type, p_data, format);
}
CIMGUI_API int igDataTypeCompare(ImGuiDataType data_type,
                                 const void* arg_1,
                                 const void* arg_2) {
  return ImGui::DataTypeCompare(data_type, arg_1, arg_2);
}
CIMGUI_API bool igDataTypeClamp(ImGuiDataType data_type,
                                void* p_data,
                                const void* p_min,
                                const void* p_max) {
  return ImGui::DataTypeClamp(data_type, p_data, p_min, p_max);
}
CIMGUI_API bool igInputTextEx(const char* label,
                              const char* hint,
                              char* buf,
                              int buf_size,
                              const ImVec2 size_arg,
                              ImGuiInputTextFlags flags,
                              ImGuiInputTextCallback callback,
                              void* user_data) {
  return ImGui::InputTextEx(label, hint, buf, buf_size, size_arg, flags,
                            callback, user_data);
}
CIMGUI_API void igInputTextDeactivateHook(ImGuiID id) {
  return ImGui::InputTextDeactivateHook(id);
}
CIMGUI_API bool igTempInputText(const ImRect bb,
                                ImGuiID id,
                                const char* label,
                                char* buf,
                                int buf_size,
                                ImGuiInputTextFlags flags) {
  return ImGui::TempInputText(bb, id, label, buf, buf_size, flags);
}
CIMGUI_API bool igTempInputScalar(const ImRect bb,
                                  ImGuiID id,
                                  const char* label,
                                  ImGuiDataType data_type,
                                  void* p_data,
                                  const char* format,
                                  const void* p_clamp_min,
                                  const void* p_clamp_max) {
  return ImGui::TempInputScalar(bb, id, label, data_type, p_data, format,
                                p_clamp_min, p_clamp_max);
}
CIMGUI_API bool igTempInputIsActive(ImGuiID id) {
  return ImGui::TempInputIsActive(id);
}
CIMGUI_API ImGuiInputTextState* igGetInputTextState(ImGuiID id) {
  return ImGui::GetInputTextState(id);
}
CIMGUI_API void igColorTooltip(const char* text,
                               const float* col,
                               ImGuiColorEditFlags flags) {
  return ImGui::ColorTooltip(text, col, flags);
}
CIMGUI_API void igColorEditOptionsPopup(const float* col,
                                        ImGuiColorEditFlags flags) {
  return ImGui::ColorEditOptionsPopup(col, flags);
}
CIMGUI_API void igColorPickerOptionsPopup(const float* ref_col,
                                          ImGuiColorEditFlags flags) {
  return ImGui::ColorPickerOptionsPopup(ref_col, flags);
}
CIMGUI_API int igPlotEx(ImGuiPlotType plot_type,
                        const char* label,
                        float (*values_getter)(void* data, int idx),
                        void* data,
                        int values_count,
                        int values_offset,
                        const char* overlay_text,
                        float scale_min,
                        float scale_max,
                        const ImVec2 size_arg) {
  return ImGui::PlotEx(plot_type, label, values_getter, data, values_count,
                       values_offset, overlay_text, scale_min, scale_max,
                       size_arg);
}
CIMGUI_API void igShadeVertsLinearColorGradientKeepAlpha(ImDrawList* draw_list,
                                                         int vert_start_idx,
                                                         int vert_end_idx,
                                                         ImVec2 gradient_p0,
                                                         ImVec2 gradient_p1,
                                                         ImU32 col0,
                                                         ImU32 col1) {
  return ImGui::ShadeVertsLinearColorGradientKeepAlpha(
      draw_list, vert_start_idx, vert_end_idx, gradient_p0, gradient_p1, col0,
      col1);
}
CIMGUI_API void igShadeVertsLinearUV(ImDrawList* draw_list,
                                     int vert_start_idx,
                                     int vert_end_idx,
                                     const ImVec2 a,
                                     const ImVec2 b,
                                     const ImVec2 uv_a,
                                     const ImVec2 uv_b,
                                     bool clamp) {
  return ImGui::ShadeVertsLinearUV(draw_list, vert_start_idx, vert_end_idx, a,
                                   b, uv_a, uv_b, clamp);
}
CIMGUI_API void igShadeVertsTransformPos(ImDrawList* draw_list,
                                         int vert_start_idx,
                                         int vert_end_idx,
                                         const ImVec2 pivot_in,
                                         float cos_a,
                                         float sin_a,
                                         const ImVec2 pivot_out) {
  return ImGui::ShadeVertsTransformPos(draw_list, vert_start_idx, vert_end_idx,
                                       pivot_in, cos_a, sin_a, pivot_out);
}
CIMGUI_API void igGcCompactTransientMiscBuffers() {
  return ImGui::GcCompactTransientMiscBuffers();
}
CIMGUI_API void igGcCompactTransientWindowBuffers(ImGuiWindow* window) {
  return ImGui::GcCompactTransientWindowBuffers(window);
}
CIMGUI_API void igGcAwakeTransientWindowBuffers(ImGuiWindow* window) {
  return ImGui::GcAwakeTransientWindowBuffers(window);
}
CIMGUI_API void igDebugLog(const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);
  ImGui::DebugLogV(fmt, args);
  va_end(args);
}
CIMGUI_API void igDebugLogV(const char* fmt, va_list args) {
  return ImGui::DebugLogV(fmt, args);
}
CIMGUI_API void igDebugAllocHook(ImGuiDebugAllocInfo* info,
                                 int frame_count,
                                 void* ptr,
                                 size_t size) {
  return ImGui::DebugAllocHook(info, frame_count, ptr, size);
}
CIMGUI_API void igErrorCheckEndFrameRecover(ImGuiErrorLogCallback log_callback,
                                            void* user_data) {
  return ImGui::ErrorCheckEndFrameRecover(log_callback, user_data);
}
CIMGUI_API void igErrorCheckEndWindowRecover(ImGuiErrorLogCallback log_callback,
                                             void* user_data) {
  return ImGui::ErrorCheckEndWindowRecover(log_callback, user_data);
}
CIMGUI_API void igErrorCheckUsingSetCursorPosToExtendParentBoundaries() {
  return ImGui::ErrorCheckUsingSetCursorPosToExtendParentBoundaries();
}
CIMGUI_API void igDebugDrawCursorPos(ImU32 col) {
  return ImGui::DebugDrawCursorPos(col);
}
CIMGUI_API void igDebugDrawLineExtents(ImU32 col) {
  return ImGui::DebugDrawLineExtents(col);
}
CIMGUI_API void igDebugDrawItemRect(ImU32 col) {
  return ImGui::DebugDrawItemRect(col);
}
CIMGUI_API void igDebugLocateItem(ImGuiID target_id) {
  return ImGui::DebugLocateItem(target_id);
}
CIMGUI_API void igDebugLocateItemOnHover(ImGuiID target_id) {
  return ImGui::DebugLocateItemOnHover(target_id);
}
CIMGUI_API void igDebugLocateItemResolveWithLastItem() {
  return ImGui::DebugLocateItemResolveWithLastItem();
}
CIMGUI_API void igDebugBreakClearData() {
  return ImGui::DebugBreakClearData();
}
CIMGUI_API bool igDebugBreakButton(const char* label,
                                   const char* description_of_location) {
  return ImGui::DebugBreakButton(label, description_of_location);
}
CIMGUI_API void igDebugBreakButtonTooltip(bool keyboard_only,
                                          const char* description_of_location) {
  return ImGui::DebugBreakButtonTooltip(keyboard_only, description_of_location);
}
CIMGUI_API void igShowFontAtlas(ImFontAtlas* atlas) {
  return ImGui::ShowFontAtlas(atlas);
}
CIMGUI_API void igDebugHookIdInfo(ImGuiID id,
                                  ImGuiDataType data_type,
                                  const void* data_id,
                                  const void* data_id_end) {
  return ImGui::DebugHookIdInfo(id, data_type, data_id, data_id_end);
}
CIMGUI_API void igDebugNodeColumns(ImGuiOldColumns* columns) {
  return ImGui::DebugNodeColumns(columns);
}
CIMGUI_API void igDebugNodeDockNode(ImGuiDockNode* node, const char* label) {
  return ImGui::DebugNodeDockNode(node, label);
}
CIMGUI_API void igDebugNodeDrawList(ImGuiWindow* window,
                                    ImGuiViewportP* viewport,
                                    const ImDrawList* draw_list,
                                    const char* label) {
  return ImGui::DebugNodeDrawList(window, viewport, draw_list, label);
}
CIMGUI_API void igDebugNodeDrawCmdShowMeshAndBoundingBox(
    ImDrawList* out_draw_list,
    const ImDrawList* draw_list,
    const ImDrawCmd* draw_cmd,
    bool show_mesh,
    bool show_aabb) {
  return ImGui::DebugNodeDrawCmdShowMeshAndBoundingBox(
      out_draw_list, draw_list, draw_cmd, show_mesh, show_aabb);
}
CIMGUI_API void igDebugNodeFont(ImFont* font) {
  return ImGui::DebugNodeFont(font);
}
CIMGUI_API void igDebugNodeFontGlyph(ImFont* font, const ImFontGlyph* glyph) {
  return ImGui::DebugNodeFontGlyph(font, glyph);
}
CIMGUI_API void igDebugNodeStorage(ImGuiStorage* storage, const char* label) {
  return ImGui::DebugNodeStorage(storage, label);
}
CIMGUI_API void igDebugNodeTabBar(ImGuiTabBar* tab_bar, const char* label) {
  return ImGui::DebugNodeTabBar(tab_bar, label);
}
CIMGUI_API void igDebugNodeTable(ImGuiTable* table) {
  return ImGui::DebugNodeTable(table);
}
CIMGUI_API void igDebugNodeTableSettings(ImGuiTableSettings* settings) {
  return ImGui::DebugNodeTableSettings(settings);
}
CIMGUI_API void igDebugNodeInputTextState(ImGuiInputTextState* state) {
  return ImGui::DebugNodeInputTextState(state);
}
CIMGUI_API void igDebugNodeTypingSelectState(ImGuiTypingSelectState* state) {
  return ImGui::DebugNodeTypingSelectState(state);
}
CIMGUI_API void igDebugNodeWindow(ImGuiWindow* window, const char* label) {
  return ImGui::DebugNodeWindow(window, label);
}
CIMGUI_API void igDebugNodeWindowSettings(ImGuiWindowSettings* settings) {
  return ImGui::DebugNodeWindowSettings(settings);
}
CIMGUI_API void igDebugNodeWindowsList(ImVector_ImGuiWindowPtr* windows,
                                       const char* label) {
  return ImGui::DebugNodeWindowsList(windows, label);
}
CIMGUI_API void igDebugNodeWindowsListByBeginStackParent(
    ImGuiWindow** windows,
    int windows_size,
    ImGuiWindow* parent_in_begin_stack) {
  return ImGui::DebugNodeWindowsListByBeginStackParent(windows, windows_size,
                                                       parent_in_begin_stack);
}
CIMGUI_API void igDebugNodeViewport(ImGuiViewportP* viewport) {
  return ImGui::DebugNodeViewport(viewport);
}
CIMGUI_API void igDebugRenderKeyboardPreview(ImDrawList* draw_list) {
  return ImGui::DebugRenderKeyboardPreview(draw_list);
}
CIMGUI_API void igDebugRenderViewportThumbnail(ImDrawList* draw_list,
                                               ImGuiViewportP* viewport,
                                               const ImRect bb) {
  return ImGui::DebugRenderViewportThumbnail(draw_list, viewport, bb);
}

CIMGUI_API void igImFontAtlasUpdateConfigDataPointers(ImFontAtlas* atlas) {
  return ImFontAtlasUpdateConfigDataPointers(atlas);
}
CIMGUI_API void igImFontAtlasBuildInit(ImFontAtlas* atlas) {
  return ImFontAtlasBuildInit(atlas);
}
CIMGUI_API void igImFontAtlasBuildSetupFont(ImFontAtlas* atlas,
                                            ImFont* font,
                                            ImFontConfig* font_config,
                                            float ascent,
                                            float descent) {
  return ImFontAtlasBuildSetupFont(atlas, font, font_config, ascent, descent);
}
CIMGUI_API void igImFontAtlasBuildPackCustomRects(ImFontAtlas* atlas,
                                                  void* stbrp_context_opaque) {
  return ImFontAtlasBuildPackCustomRects(atlas, stbrp_context_opaque);
}
CIMGUI_API void igImFontAtlasBuildFinish(ImFontAtlas* atlas) {
  return ImFontAtlasBuildFinish(atlas);
}
CIMGUI_API void igImFontAtlasBuildRender8bppRectFromString(
    ImFontAtlas* atlas,
    int x,
    int y,
    int w,
    int h,
    const char* in_str,
    char in_marker_char,
    unsigned char in_marker_pixel_value) {
  return ImFontAtlasBuildRender8bppRectFromString(
      atlas, x, y, w, h, in_str, in_marker_char, in_marker_pixel_value);
}
CIMGUI_API void igImFontAtlasBuildRender32bppRectFromString(
    ImFontAtlas* atlas,
    int x,
    int y,
    int w,
    int h,
    const char* in_str,
    char in_marker_char,
    unsigned int in_marker_pixel_value) {
  return ImFontAtlasBuildRender32bppRectFromString(
      atlas, x, y, w, h, in_str, in_marker_char, in_marker_pixel_value);
}
CIMGUI_API void igImFontAtlasBuildMultiplyCalcLookupTable(
    unsigned char out_table[256],
    float in_multiply_factor) {
  return ImFontAtlasBuildMultiplyCalcLookupTable(out_table, in_multiply_factor);
}
CIMGUI_API void igImFontAtlasBuildMultiplyRectAlpha8(
    const unsigned char table[256],
    unsigned char* pixels,
    int x,
    int y,
    int w,
    int h,
    int stride) {
  return ImFontAtlasBuildMultiplyRectAlpha8(table, pixels, x, y, w, h, stride);
}

/////////////////////////////manual written functions
CIMGUI_API void igLogText(CONST char* fmt, ...) {
  char buffer[256];
  va_list args;
  va_start(args, fmt);
  vsnprintf(buffer, 256, fmt, args);
  va_end(args);

  ImGui::LogText("%s", buffer);
}
CIMGUI_API void ImGuiTextBuffer_appendf(struct ImGuiTextBuffer* buffer,
                                        const char* fmt,
                                        ...) {
  va_list args;
  va_start(args, fmt);
  buffer->appendfv(fmt, args);
  va_end(args);
}

CIMGUI_API float igGET_FLT_MAX() {
  return FLT_MAX;
}

CIMGUI_API float igGET_FLT_MIN() {
  return FLT_MIN;
}

CIMGUI_API ImVector_ImWchar* ImVector_ImWchar_create() {
  return IM_NEW(ImVector<ImWchar>)();
}

CIMGUI_API void ImVector_ImWchar_destroy(ImVector_ImWchar* self) {
  IM_DELETE(self);
}

CIMGUI_API void ImVector_ImWchar_Init(ImVector_ImWchar* p) {
  IM_PLACEMENT_NEW(p) ImVector<ImWchar>();
}
CIMGUI_API void ImVector_ImWchar_UnInit(ImVector_ImWchar* p) {
  p->~ImVector<ImWchar>();
}

#ifdef IMGUI_HAS_DOCK

// NOTE: Some function pointers in the ImGuiPlatformIO structure are not
// C-compatible because of their use of a complex return type. To work around
// this, we store a custom CimguiStorage object inside
// ImGuiIO::BackendLanguageUserData, which contains C-compatible function
// pointer variants for these functions. When a user function pointer is
// provided, we hook up the underlying ImGuiPlatformIO function pointer to a
// thunk which accesses the user function pointer through CimguiStorage.

struct CimguiStorage {
  void (*Platform_GetWindowPos)(ImGuiViewport* vp, ImVec2* out_pos);
  void (*Platform_GetWindowSize)(ImGuiViewport* vp, ImVec2* out_pos);
};

// Gets a reference to the CimguiStorage object stored in the current ImGui
// context's BackendLanguageUserData.
CimguiStorage& GetCimguiStorage() {
  ImGuiIO& io = ImGui::GetIO();
  if (io.BackendLanguageUserData == NULL) {
    io.BackendLanguageUserData = new CimguiStorage();
  }

  return *(CimguiStorage*)io.BackendLanguageUserData;
}

// Thunk satisfying the signature of ImGuiPlatformIO::Platform_GetWindowPos.
ImVec2 Platform_GetWindowPos_hook(ImGuiViewport* vp) {
  ImVec2 pos;
  GetCimguiStorage().Platform_GetWindowPos(vp, &pos);
  return pos;
};

// Fully C-compatible function pointer setter for
// ImGuiPlatformIO::Platform_GetWindowPos.
CIMGUI_API void ImGuiPlatformIO_Set_Platform_GetWindowPos(
    ImGuiPlatformIO* platform_io,
    void (*user_callback)(ImGuiViewport* vp, ImVec2* out_pos)) {
  CimguiStorage& storage = GetCimguiStorage();
  storage.Platform_GetWindowPos = user_callback;
  platform_io->Platform_GetWindowPos = &Platform_GetWindowPos_hook;
}

// Thunk satisfying the signature of ImGuiPlatformIO::Platform_GetWindowSize.
ImVec2 Platform_GetWindowSize_hook(ImGuiViewport* vp) {
  ImVec2 size;
  GetCimguiStorage().Platform_GetWindowSize(vp, &size);
  return size;
};

// Fully C-compatible function pointer setter for
// ImGuiPlatformIO::Platform_GetWindowSize.
CIMGUI_API void ImGuiPlatformIO_Set_Platform_GetWindowSize(
    ImGuiPlatformIO* platform_io,
    void (*user_callback)(ImGuiViewport* vp, ImVec2* out_size)) {
  CimguiStorage& storage = GetCimguiStorage();
  storage.Platform_GetWindowSize = user_callback;
  platform_io->Platform_GetWindowSize = &Platform_GetWindowSize_hook;
}

#endif