Global Namespace

Overview

// namespaces

namespace ImGui;
namespace ImGuiFreeType;
namespace ImPlot;
namespace ImStb;
namespace MyImPlot;
namespace gtsam;
namespace literals;
namespace mola;
    namespace mola::detail;
    namespace mola::factors;
    namespace mola::gui;
    namespace mola::kf_cli;
    namespace mola::state_estimation_simple;
    namespace mola::state_estimation_smoother;
namespace mp2p_icp;
namespace mrpt;
    namespace mrpt::config;
    namespace mrpt::maps;
    namespace mrpt::obs;
    namespace mrpt::rtti;
    namespace mrpt::serialization;
    namespace mrpt::system;
namespace rosbag2_cpp;
    namespace rosbag2_cpp::readers;
namespace rosbag2_storage;
namespace std;
namespace string_literals;
namespace tf2;
namespace tsl;
    namespace tsl::detail_robin_hash;
    namespace tsl::rh;
        namespace tsl::rh::detail;

// typedefs

typedef boost::mpl::list<tsl::rh::power_of_two_growth_policy<2>, tsl::rh::power_of_two_growth_policy<4>, tsl::rh::prime_growth_policy, tsl::rh::mod_growth_policy<>, tsl::rh::mod_growth_policy<std::ratio<7, 2>>> test_types;
typedef boost::mpl::list<tsl::robin_map<std::int64_t, std::int64_t>, tsl::robin_map<std::string, std::string>, tsl::robin_map<std::int64_t, std::int64_t, mod_hash<9>>, tsl::robin_map<std::string, std::string, mod_hash<9>>, tsl::robin_map<move_only_test, move_only_test, mod_hash<9>>, tsl::robin_map<copy_only_test, copy_only_test, mod_hash<9>>, tsl::robin_map<self_reference_member_test, self_reference_member_test, mod_hash<9>>, tsl::robin_map<move_only_test, move_only_test, mod_hash<9>, std::equal_to<move_only_test>, std::allocator<std::pair<move_only_test, move_only_test>>, true, tsl::rh::power_of_two_growth_policy<4>>, tsl::robin_pg_map<move_only_test, move_only_test, mod_hash<9>>, tsl::robin_map<move_only_test, move_only_test, mod_hash<9>, std::equal_to<move_only_test>, std::allocator<std::pair<move_only_test, move_only_test>>, false, tsl::rh::mod_growth_policy<>>, tsl::robin_map<copy_only_test, copy_only_test, mod_hash<9>, std::equal_to<copy_only_test>, std::allocator<std::pair<copy_only_test, copy_only_test>>, false, tsl::rh::power_of_two_growth_policy<4>>, tsl::robin_pg_map<copy_only_test, copy_only_test, mod_hash<9>>, tsl::robin_map<copy_only_test, copy_only_test, mod_hash<9>, std::equal_to<copy_only_test>, std::allocator<std::pair<copy_only_test, copy_only_test>>, true, tsl::rh::mod_growth_policy<>>> test_types;
typedef boost::mpl::list<tsl::robin_set<std::int64_t>, tsl::robin_set<std::string>, tsl::robin_set<self_reference_member_test>, tsl::robin_set<move_only_test>, tsl::robin_pg_set<self_reference_member_test>, tsl::robin_set<move_only_test, std::hash<move_only_test>, std::equal_to<move_only_test>, std::allocator<move_only_test>, true, tsl::rh::prime_growth_policy>, tsl::robin_set<self_reference_member_test, std::hash<self_reference_member_test>, std::equal_to<self_reference_member_test>, std::allocator<self_reference_member_test>, true, tsl::rh::mod_growth_policy<>>, tsl::robin_set<move_only_test, std::hash<move_only_test>, std::equal_to<move_only_test>, std::allocator<move_only_test>, false, tsl::rh::mod_growth_policy<>>> test_types;
typedef float khronos_float_t;
typedef signed char khronos_int8_t;
typedef unsigned char khronos_uint8_t;
typedef signed short int khronos_int16_t;
typedef unsigned short int khronos_uint16_t;
typedef signed long int khronos_intptr_t;
typedef signed long int khronos_ssize_t;
typedef signed long long khronos_int64_t;
typedef unsigned long long khronos_uint64_t;
typedef void GLvoid;
typedef unsigned int GLenum;
typedef khronos_float_t GLfloat;
typedef int GLint;
typedef int GLsizei;
typedef unsigned int GLbitfield;
typedef double GLdouble;
typedef unsigned int GLuint;
typedef unsigned char GLboolean;
typedef khronos_uint8_t GLubyte;
typedef GLenum mode;
typedef GLint y;
typedef GLint GLsizei width;
typedef GLint GLsizei GLsizei height;
typedef GLenum pname;
typedef GLenum GLint param;
typedef GLint level;
typedef GLint GLint internalformat;
typedef GLint GLint GLsizei GLsizei GLint border;
typedef GLint GLint GLsizei GLsizei GLint GLenum format;
typedef GLint GLint GLsizei GLsizei GLint GLenum GLenum type;
typedef GLint GLint GLsizei GLsizei GLint GLenum GLenum const void* pixels;
typedef GLfloat green;
typedef GLfloat GLfloat blue;
typedef GLfloat GLfloat GLfloat alpha;
typedef GLint* data;
typedef const GLubyte*APIENTRYP PFNGLGETSTRINGPROC(GLenum name);
typedef khronos_float_t GLclampf;
typedef double GLclampd;
typedef GLsizei count;
typedef GLsizei GLenum const void* indices;
typedef GLint GLint xoffset;
typedef GLint GLint GLint yoffset;
typedef GLuint texture;
typedef const GLuint* textures;
typedef GLenum dfactorRGB;
typedef GLenum GLenum sfactorAlpha;
typedef GLenum GLenum GLenum dfactorAlpha;
typedef khronos_ssize_t GLsizeiptr;
typedef khronos_intptr_t GLintptr;
typedef GLuint buffer;
typedef const GLuint* buffers;
typedef GLsizeiptr size;
typedef GLsizeiptr const void GLenum usage;
typedef GLintptr offset;
typedef char GLchar;
typedef khronos_int16_t GLshort;
typedef khronos_int8_t GLbyte;
typedef khronos_uint16_t GLushort;
typedef GLenum modeAlpha;
typedef GLuint shader;
typedef const GLchar* name;
typedef GLenum GLint* params;
typedef GLsizei bufSize;
typedef GLsizei GLsizei* length;
typedef GLsizei GLsizei GLchar* infoLog;
typedef GLenum void** pointer;
typedef GLsizei const GLchar*const* string;
typedef GLint v0;
typedef GLsizei GLboolean transpose;
typedef GLsizei GLboolean const GLfloat* value;
typedef GLint GLenum GLboolean normalized;
typedef GLint GLenum GLboolean GLsizei stride;
typedef khronos_uint16_t GLhalf;
typedef GLuint index;

typedef const GLubyte*APIENTRYP PFNGLGETSTRINGIPROC(
    GLenum name,
    GLuint index
    );

typedef const GLuint* arrays;
typedef struct __GLsync* GLsync;
typedef khronos_uint64_t GLuint64;
typedef khronos_int64_t GLint64;
typedef GLsizei GLenum const void GLint basevertex;
typedef GLuint* samplers;
typedef GLuint sampler;

typedef void(APIENTRY* GLDEBUGPROC)(
    GLenum source,
    GLenum type,
    GLuint id,
    GLenum severity,
    GLsizei length,
    const GLchar *message,
    const void *userParam
    );

typedef khronos_uint64_t GLuint64EXT;

typedef void(APIENTRY* GLDEBUGPROCARB)(
    GLenum source,
    GLenum type,
    GLuint id,
    GLenum severity,
    GLsizei length,
    const GLchar *message,
    const void *userParam
    );

typedef void* GLeglImageOES;
typedef void(APIENTRY* GLVULKANPROCNV)(void);
typedef khronos_int64_t GLint64EXT;
typedef GLuint GLuint64EXT* result;
typedef void (*GL3WglProc)(void);
typedef GL3WglProc (*GL3WGetProcAddressProc)(const char *proc);
typedef void VkPipelineRenderingCreateInfoKHR;

typedef DWORD(WINAPI* PFN_XInputGetCapabilities)(
    DWORD,
    DWORD,
    XINPUT_CAPABILITIES *
    );

typedef DWORD(WINAPI* PFN_XInputGetState)(
    DWORD,
    XINPUT_STATE *
    );

typedef HRESULT(WINAPI* PFN_SetProcessDpiAwareness)(PROCESS_DPI_AWARENESS);

typedef HRESULT(WINAPI* PFN_GetDpiForMonitor)(
    HMONITOR,
    MONITOR_DPI_TYPE,
    UINT *,
    UINT *
    );

typedef DPI_AWARENESS_CONTEXT(WINAPI* PFN_SetThreadDpiAwarenessContext)(DPI_AWARENESS_CONTEXT);
typedef void (*GLFWglproc)(void);
typedef void (*GLFWvkproc)(void);
typedef struct GLFWmonitor GLFWmonitor;
typedef struct GLFWwindow GLFWwindow;
typedef struct GLFWcursor GLFWcursor;

typedef void (*GLFWerrorfun)(
    int,
    const char *
    );

typedef void (*GLFWwindowposfun)(
    GLFWwindow *,
    int,
    int
    );

typedef void (*GLFWwindowsizefun)(
    GLFWwindow *,
    int,
    int
    );

typedef void (*GLFWwindowclosefun)(GLFWwindow *);
typedef void (*GLFWwindowrefreshfun)(GLFWwindow *);

typedef void (*GLFWwindowfocusfun)(
    GLFWwindow *,
    int
    );

typedef void (*GLFWwindowiconifyfun)(
    GLFWwindow *,
    int
    );

typedef void (*GLFWframebuffersizefun)(
    GLFWwindow *,
    int,
    int
    );

typedef void (*GLFWmousebuttonfun)(
    GLFWwindow *,
    int,
    int,
    int
    );

typedef void (*GLFWcursorposfun)(
    GLFWwindow *,
    double,
    double
    );

typedef void (*GLFWcursorenterfun)(
    GLFWwindow *,
    int
    );

typedef void (*GLFWscrollfun)(
    GLFWwindow *,
    double,
    double
    );

typedef void (*GLFWkeyfun)(
    GLFWwindow *,
    int,
    int,
    int,
    int
    );

typedef void (*GLFWcharfun)(
    GLFWwindow *,
    unsigned int
    );

typedef void (*GLFWcharmodsfun)(
    GLFWwindow *,
    unsigned int,
    int
    );

typedef void (*GLFWdropfun)(
    GLFWwindow *,
    int,
    const char **
    );

typedef void (*GLFWmonitorfun)(
    GLFWmonitor *,
    int
    );

typedef void (*GLFWjoystickfun)(
    int,
    int
    );

typedef struct GLFWvidmode GLFWvidmode;
typedef struct GLFWgammaramp GLFWgammaramp;
typedef struct GLFWimage GLFWimage;
typedef int uSynergyBool;
typedef uSynergyBool (*uSynergyConnectFunc)(uSynergyCookie cookie);

typedef uSynergyBool (*uSynergySendFunc)(
    uSynergyCookie cookie,
    const uint8_t *buffer,
    int length
    );

typedef uSynergyBool (*uSynergyReceiveFunc)(
    uSynergyCookie cookie,
    uint8_t *buffer,
    int maxLength,
    int *outLength
    );

typedef void (*uSynergySleepFunc)(
    uSynergyCookie cookie,
    int timeMs
    );

typedef uint32_t (*uSynergyGetTimeFunc)();

typedef void (*uSynergyTraceFunc)(
    uSynergyCookie cookie,
    const char *text
    );

typedef void (*uSynergyScreenActiveCallback)(
    uSynergyCookie cookie,
    uSynergyBool active
    );

typedef void (*uSynergyMouseCallback)(
    uSynergyCookie cookie,
    uint16_t x,
    uint16_t y,
    int16_t wheelX,
    int16_t wheelY,
    uSynergyBool buttonLeft,
    uSynergyBool buttonRight,
    uSynergyBool buttonMiddle
    );

typedef void (*uSynergyKeyboardCallback)(
    uSynergyCookie cookie,
    uint16_t key,
    uint16_t modifiers,
    uSynergyBool down,
    uSynergyBool repeat
    );

typedef void (*uSynergyJoystickCallback)(
    uSynergyCookie cookie,
    uint8_t joyNum,
    uint16_t buttons,
    int8_t leftStickX,
    int8_t leftStickY,
    int8_t rightStickX,
    int8_t rightStickY
    );

typedef void (*uSynergyClipboardCallback)(
    uSynergyCookie cookie,
    enum uSynergyClipboardFormat format,
    const uint8_t *data,
    uint32_t size
    );

typedef unsigned int ImGuiID;
typedef signed char ImS8;
typedef unsigned char ImU8;
typedef signed short ImS16;
typedef unsigned short ImU16;
typedef signed int ImS32;
typedef unsigned int ImU32;
typedef signed long long ImS64;
typedef unsigned long long ImU64;
typedef void (*ImGuiSizeCallback)(ImGuiSizeCallbackData *data);

typedef void* (*ImGuiMemAllocFunc)(
    size_t sz,
    void *user_data
    );

typedef void (*ImGuiMemFreeFunc)(
    void *ptr,
    void *user_data
    );

typedef unsigned short ImDrawIdx;

typedef void (*ImDrawCallback)(
    const ImDrawList *parent_list,
    const ImDrawCmd *cmd
    );

typedef int ImFontAtlasRectId;
typedef ImFontAtlasRect ImFontAtlasCustomRect;
typedef FILE* ImFileHandle;
typedef ImU32* ImBitArrayPtr;
typedef int ImPoolIdx;
typedef ImStb::STB_TexteditState ImStbTexteditState;
typedef ImBitArray<ImGuiKey_NamedKey_COUNT, -ImGuiKey_NamedKey_BEGIN> ImBitArrayForNamedKeys;
typedef ImS16 ImGuiKeyRoutingIndex;

typedef void (*ImGuiErrorCallback)(
    ImGuiContext *ctx,
    void *user_data,
    const char *msg
    );

typedef void (*ImGuiContextHookCallback)(
    ImGuiContext *ctx,
    ImGuiContextHook *hook
    );

typedef void (*ImGuiDemoMarkerCallback)(
    const char *file,
    int line,
    const char *section
    );

typedef ImFontLoader ImFontBuilderIO;
typedef stbrp_node stbrp_node_im;
typedef int stbrp_coord;
typedef unsigned int stb_uint;
typedef unsigned char stb_uchar;
typedef unsigned int ImGuiFreeTypeLoaderFlags;
typedef ImGuiFreeTypeLoaderFlags_ ImGuiFreeTypeBuilderFlags_;
typedef int ImAxis;
typedef int ImPlotProp;
typedef int ImPlotFlags;
typedef int ImPlotAxisFlags;
typedef int ImPlotSubplotFlags;
typedef int ImPlotLegendFlags;
typedef int ImPlotMouseTextFlags;
typedef int ImPlotDragToolFlags;
typedef int ImPlotColormapScaleFlags;
typedef int ImPlotItemFlags;
typedef int ImPlotLineFlags;
typedef int ImPlotScatterFlags;
typedef int ImPlotBubblesFlags;
typedef int ImPlotPolygonFlags;
typedef int ImPlotStairsFlags;
typedef int ImPlotShadedFlags;
typedef int ImPlotBarsFlags;
typedef int ImPlotBarGroupsFlags;
typedef int ImPlotErrorBarsFlags;
typedef int ImPlotStemsFlags;
typedef int ImPlotInfLinesFlags;
typedef int ImPlotPieChartFlags;
typedef int ImPlotHeatmapFlags;
typedef int ImPlotHistogramFlags;
typedef int ImPlotDigitalFlags;
typedef int ImPlotImageFlags;
typedef int ImPlotTextFlags;
typedef int ImPlotDummyFlags;
typedef int ImPlotCond;
typedef int ImPlotCol;
typedef int ImPlotStyleVar;
typedef int ImPlotScale;
typedef int ImPlotMarker;
typedef int ImPlotColormap;
typedef int ImPlotLocation;
typedef int ImPlotBin;

typedef int (*ImPlotFormatter)(
    double value,
    char *buff,
    int size,
    void *user_data
    );

typedef ImPlotPoint (*ImPlotGetter)(
    int idx,
    void *user_data
    );

typedef double (*ImPlotTransform)(
    double value,
    void *user_data
    );

typedef int ImPlotTimeUnit;
typedef int ImPlotDateFmt;
typedef int ImPlotTimeFmt;
typedef int ImPlotMarkerInternal;

typedef void (*ImPlotLocator)(
    ImPlotTicker &ticker,
    const ImPlotRange &range,
    float pixels,
    bool vertical,
    ImPlotFormatter formatter,
    void *formatter_data
    );

typedef mrpt::math::CMatrixDouble44 Matrix;

// enums

enum
{
    STBTT_vmove  =1,
    STBTT_vline,
    STBTT_vcurve,
    STBTT_vcubic,
};

enum
{
    STBTT_PLATFORM_ID_UNICODE   =0,
    STBTT_PLATFORM_ID_MAC       =1,
    STBTT_PLATFORM_ID_ISO       =2,
    STBTT_PLATFORM_ID_MICROSOFT =3,
};

enum
{
    STBTT_UNICODE_EID_UNICODE_1_0      =0,
    STBTT_UNICODE_EID_UNICODE_1_1      =1,
    STBTT_UNICODE_EID_ISO_10646        =2,
    STBTT_UNICODE_EID_UNICODE_2_0_BMP  =3,
    STBTT_UNICODE_EID_UNICODE_2_0_FULL =4,
};

enum
{
    STBTT_MS_EID_SYMBOL       =0,
    STBTT_MS_EID_UNICODE_BMP  =1,
    STBTT_MS_EID_SHIFTJIS     =2,
    STBTT_MS_EID_UNICODE_FULL =10,
};

enum
{
    STBTT_MAC_EID_ROMAN        =0,
    STBTT_MAC_EID_ARABIC       =4,
    STBTT_MAC_EID_JAPANESE     =1,
    STBTT_MAC_EID_HEBREW       =5,
    STBTT_MAC_EID_CHINESE_TRAD =2,
    STBTT_MAC_EID_GREEK        =6,
    STBTT_MAC_EID_KOREAN       =3,
    STBTT_MAC_EID_RUSSIAN      =7,
};

enum
{
    STBTT_MS_LANG_ENGLISH  =0x0409,
    STBTT_MS_LANG_ITALIAN  =0x0410,
    STBTT_MS_LANG_CHINESE  =0x0804,
    STBTT_MS_LANG_JAPANESE =0x0411,
    STBTT_MS_LANG_DUTCH    =0x0413,
    STBTT_MS_LANG_KOREAN   =0x0412,
    STBTT_MS_LANG_FRENCH   =0x040c,
    STBTT_MS_LANG_RUSSIAN  =0x0419,
    STBTT_MS_LANG_GERMAN   =0x0407,
    STBTT_MS_LANG_SPANISH  =0x0409,
    STBTT_MS_LANG_HEBREW   =0x040d,
    STBTT_MS_LANG_SWEDISH  =0x041D,
};

enum
{
    STBTT_MAC_LANG_ENGLISH            =0,
    STBTT_MAC_LANG_JAPANESE           =11,
    STBTT_MAC_LANG_ARABIC             =12,
    STBTT_MAC_LANG_KOREAN             =23,
    STBTT_MAC_LANG_DUTCH              =4,
    STBTT_MAC_LANG_RUSSIAN            =32,
    STBTT_MAC_LANG_FRENCH             =1,
    STBTT_MAC_LANG_SPANISH            =6,
    STBTT_MAC_LANG_GERMAN             =2,
    STBTT_MAC_LANG_SWEDISH            =5,
    STBTT_MAC_LANG_HEBREW             =10,
    STBTT_MAC_LANG_CHINESE_SIMPLIFIED =33,
    STBTT_MAC_LANG_ITALIAN            =3,
    STBTT_MAC_LANG_CHINESE_TRAD       =19,
};

enum
{
    STBRP_HEURISTIC_Skyline_default       =0,
    STBRP_HEURISTIC_Skyline_BL_sortHeight = STBRP_HEURISTIC_Skyline_default,
    STBRP_HEURISTIC_Skyline_BF_sortHeight,
};

enum GlfwClientApi;
enum ImAxis_;
enum ImDrawFlags_;
enum ImDrawListFlags_;
enum ImDrawTextFlags_;
enum ImFontAtlasFlags_;
enum ImFontFlags_;
enum ImGuiActivateFlags_;
enum ImGuiAxis;
enum ImGuiBackendFlags_;
enum ImGuiButtonFlagsPrivate_;
enum ImGuiButtonFlags_;
enum ImGuiChildFlags_;
enum ImGuiCol_;
enum ImGuiColorEditFlags_;
enum ImGuiComboFlagsPrivate_;
enum ImGuiComboFlags_;
enum ImGuiCond_;
enum ImGuiConfigFlags_;
enum ImGuiContextHookType;
enum ImGuiDataAuthority_;
enum ImGuiDataTypePrivate_;
enum ImGuiDataType_;
enum ImGuiDebugLogFlags_;
enum ImGuiDir;
enum ImGuiDockNodeFlagsPrivate_;
enum ImGuiDockNodeFlags_;
enum ImGuiDockNodeState;
enum ImGuiDockRequestType;
enum ImGuiDragDropFlags_;
enum ImGuiFocusRequestFlags_;
enum ImGuiFocusedFlags_;
enum ImGuiFreeTypeLoaderFlags_;
enum ImGuiHoveredFlagsPrivate_;
enum ImGuiHoveredFlags_;
enum ImGuiInputEventType;
enum ImGuiInputFlagsPrivate_;
enum ImGuiInputFlags_;
enum ImGuiInputSource;
enum ImGuiInputTextFlagsPrivate_;
enum ImGuiInputTextFlags_;
enum ImGuiItemFlagsPrivate_;
enum ImGuiItemFlags_;
enum ImGuiItemStatusFlags_;
enum ImGuiKey;
enum ImGuiLayoutType_;
enum ImGuiListClipperFlags_;
enum ImGuiLocKey;
enum ImGuiLogFlags_;
enum ImGuiMouseButton_;
enum ImGuiMouseCursor_;
enum ImGuiMouseSource;
enum ImGuiMultiSelectFlags_;
enum ImGuiNavLayer;
enum ImGuiNavMoveFlags_;
enum ImGuiNavRenderCursorFlags_;
enum ImGuiNextItemDataFlags_;
enum ImGuiNextWindowDataFlags_;
enum ImGuiOldColumnFlags_;
enum ImGuiPlotType;
enum ImGuiPopupFlags_;
enum ImGuiPopupPositionPolicy;
enum ImGuiScrollFlags_;
enum ImGuiSelectableFlagsPrivate_;
enum ImGuiSelectableFlags_;
enum ImGuiSelectionRequestType;
enum ImGuiSeparatorFlags_;
enum ImGuiSliderFlagsPrivate_;
enum ImGuiSliderFlags_;
enum ImGuiSortDirection;
enum ImGuiStyleVar_;
enum ImGuiTabBarFlagsPrivate_;
enum ImGuiTabBarFlags_;
enum ImGuiTabItemFlagsPrivate_;
enum ImGuiTabItemFlags_;
enum ImGuiTableBgTarget_;
enum ImGuiTableColumnFlags_;
enum ImGuiTableFlags_;
enum ImGuiTableRowFlags_;
enum ImGuiTextFlags_;
enum ImGuiTooltipFlags_;
enum ImGuiTreeNodeFlagsPrivate_;
enum ImGuiTreeNodeFlags_;
enum ImGuiTypingSelectFlags_;
enum ImGuiViewportFlags_;
enum ImGuiWindowBgClickFlags_;
enum ImGuiWindowDockStyleCol;
enum ImGuiWindowFlags_;
enum ImGuiWindowRefreshFlags_;
enum ImGui_ImplSDL2_GamepadMode;
enum ImGui_ImplSDL2_MouseCaptureMode;
enum ImGui_ImplSDL3_GamepadMode;
enum ImGui_ImplSDL3_MouseCaptureMode;
enum ImPlotAxisFlags_;
enum ImPlotBarGroupsFlags_;
enum ImPlotBarsFlags_;
enum ImPlotBin_;
enum ImPlotBubblesFlags_;
enum ImPlotCol_;
enum ImPlotColormapScaleFlags_;
enum ImPlotColormap_;
enum ImPlotCond_;
enum ImPlotDateFmt_;
enum ImPlotDigitalFlags_;
enum ImPlotDragToolFlags_;
enum ImPlotDummyFlags_;
enum ImPlotErrorBarsFlags_;
enum ImPlotFlags_;
enum ImPlotHeatmapFlags_;
enum ImPlotHistogramFlags_;
enum ImPlotImageFlags_;
enum ImPlotInfLinesFlags_;
enum ImPlotItemFlags_;
enum ImPlotLegendFlags_;
enum ImPlotLineFlags_;
enum ImPlotLocation_;
enum ImPlotMarkerInternal_;
enum ImPlotMarker_;
enum ImPlotMouseTextFlags_;
enum ImPlotPieChartFlags_;
enum ImPlotPolygonFlags_;
enum ImPlotProp_;
enum ImPlotScale_;
enum ImPlotScatterFlags_;
enum ImPlotShadedFlags_;
enum ImPlotStairsFlags_;
enum ImPlotStemsFlags_;
enum ImPlotStyleVar_;
enum ImPlotSubplotFlags_;
enum ImPlotTextFlags_;
enum ImPlotTimeFmt_;
enum ImPlotTimeUnit_;
enum ImTextureFormat;
enum ImTextureStatus;
enum ImTriangulatorNodeType;
enum ImWcharClass;
enum MONITOR_DPI_TYPE;
enum PROCESS_DPI_AWARENESS;
enum SourceEncoding;
enum uSynergyClipboardFormat;

// structs

struct CUSTOMVERTEX;
struct Cli;
struct ExampleAppConsole;
struct ExampleAppDocuments;
struct ExampleAppLog;
struct ExampleAppPropertyEditor;
struct ExampleAsset;
struct ExampleAssetsBrowser;
struct ExampleDescriptorHeapAllocator;
struct ExampleDualListBox;
struct ExampleMemberInfo;
struct ExampleSelectionWithDeletion;
struct ExampleTreeNode;
struct FrameContext;
struct FrameResources;
struct GLFWgammaramp;
struct GLFWimage;
struct GLFWvidmode;
struct HandlersContainer;

template <int BITCOUNT, int OFFSET = 0>
struct ImBitArray;

struct ImBitVector;

template <typename T>
struct ImChunkStream;

struct ImColor;
struct ImDrawChannel;
struct ImDrawCmd;
struct ImDrawCmdHeader;
struct ImDrawData;
struct ImDrawDataBuilder;
struct ImDrawList;
struct ImDrawListSharedData;
struct ImDrawListSplitter;
struct ImDrawVert;
struct ImDrawVertAllegro;
struct ImFont;
struct ImFontAtlas;
struct ImFontAtlasBuilder;
struct ImFontAtlasPostProcessData;
struct ImFontAtlasRect;
struct ImFontAtlasRectEntry;
struct ImFontBaked;
struct ImFontConfig;
struct ImFontGlyph;
struct ImFontGlyphRangesBuilder;
struct ImFontLoader;
struct ImFontStackData;
struct ImGuiBoxSelectState;
struct ImGuiColorMod;
struct ImGuiComboPreviewData;
struct ImGuiContext;
struct ImGuiContextHook;
struct ImGuiDataTypeInfo;
struct ImGuiDataTypeStorage;
struct ImGuiDeactivatedItemData;
struct ImGuiDebugAllocEntry;
struct ImGuiDebugAllocInfo;
struct ImGuiDebugItemPathQuery;
struct ImGuiDemoDockspaceArgs;
struct ImGuiDemoWindowData;
struct ImGuiDockContext;
struct ImGuiDockContextPruneNodeData;
struct ImGuiDockNode;
struct ImGuiDockNodeSettings;
struct ImGuiDockNodeTreeInfo;
struct ImGuiDockPreviewData;
struct ImGuiDockRequest;
struct ImGuiErrorRecoveryState;
struct ImGuiFocusScopeData;
struct ImGuiGroupData;
struct ImGuiIDStackTool;
struct ImGuiIO;
struct ImGuiInputEvent;
struct ImGuiInputEventAppFocused;
struct ImGuiInputEventKey;
struct ImGuiInputEventMouseButton;
struct ImGuiInputEventMousePos;
struct ImGuiInputEventMouseViewport;
struct ImGuiInputEventMouseWheel;
struct ImGuiInputEventText;
struct ImGuiInputTextCallbackData;
struct ImGuiInputTextDeactivatedState;
struct ImGuiInputTextState;
struct ImGuiKeyData;
struct ImGuiKeyOwnerData;
struct ImGuiKeyRoutingData;
struct ImGuiKeyRoutingTable;
struct ImGuiLastItemData;
struct ImGuiListClipper;
struct ImGuiListClipperData;
struct ImGuiListClipperRange;
struct ImGuiLocEntry;
struct ImGuiMenuColumns;
struct ImGuiMetricsConfig;
struct ImGuiMultiSelectIO;
struct ImGuiMultiSelectState;
struct ImGuiMultiSelectTempData;
struct ImGuiNavItemData;
struct ImGuiNextItemData;
struct ImGuiNextWindowData;
struct ImGuiOldColumnData;
struct ImGuiOldColumns;
struct ImGuiOnceUponAFrame;
struct ImGuiPayload;
struct ImGuiPlatformIO;
struct ImGuiPlatformImeData;
struct ImGuiPlatformMonitor;
struct ImGuiPlotArrayGetterData;
struct ImGuiPopupData;
struct ImGuiPtrOrIndex;
struct ImGuiResizeBorderDef;
struct ImGuiResizeGripDef;
struct ImGuiSelectionBasicStorage;
struct ImGuiSelectionExternalStorage;
struct ImGuiSelectionRequest;
struct ImGuiSettingsHandler;
struct ImGuiShrinkWidthItem;
struct ImGuiSizeCallbackData;
struct ImGuiStackLevelInfo;
struct ImGuiStorage;
struct ImGuiStoragePair;
struct ImGuiStyle;
struct ImGuiStyleMod;
struct ImGuiStyleVarInfo;
struct ImGuiTabBar;
struct ImGuiTabBarSection;
struct ImGuiTabItem;
struct ImGuiTable;
struct ImGuiTableCellData;
struct ImGuiTableColumn;
struct ImGuiTableColumnSettings;
struct ImGuiTableColumnSortSpecs;
struct ImGuiTableFixDisplayOrderColumnData;
struct ImGuiTableHeaderData;
struct ImGuiTableInstanceData;
struct ImGuiTableSettings;
struct ImGuiTableSortSpecs;
struct ImGuiTableTempData;
struct ImGuiTextBuffer;
struct ImGuiTextFilter;
struct ImGuiTextIndex;
struct ImGuiTreeNodeStackData;
struct ImGuiTypingSelectRequest;
struct ImGuiTypingSelectState;
struct ImGuiViewport;
struct ImGuiViewportP;
struct ImGuiWindow;
struct ImGuiWindowClass;
struct ImGuiWindowDockStyle;
struct ImGuiWindowSettings;
struct ImGuiWindowStackData;
struct ImGuiWindowTempData;
struct ImGui_ImplAllegro5_Data;
struct ImGui_ImplDX10_Data;
struct ImGui_ImplDX10_RenderState;
struct ImGui_ImplDX10_Texture;
struct ImGui_ImplDX10_ViewportData;
struct ImGui_ImplDX11_Data;
struct ImGui_ImplDX11_RenderState;
struct ImGui_ImplDX11_Texture;
struct ImGui_ImplDX11_ViewportData;
struct ImGui_ImplDX12_Data;
struct ImGui_ImplDX12_FrameContext;
struct ImGui_ImplDX12_InitInfo;
struct ImGui_ImplDX12_RenderBuffers;
struct ImGui_ImplDX12_RenderState;
struct ImGui_ImplDX12_Texture;
struct ImGui_ImplDX12_ViewportData;
struct ImGui_ImplDX9_Data;
struct ImGui_ImplDX9_ViewportData;
struct ImGui_ImplFreeType_Data;
struct ImGui_ImplFreeType_FontSrcBakedData;
struct ImGui_ImplFreeType_FontSrcData;
struct ImGui_ImplGlfw_Data;
struct ImGui_ImplGlfw_ViewportData;
struct ImGui_ImplGlfw_WindowToContext;
struct ImGui_ImplOpenGL2_Data;
struct ImGui_ImplOpenGL3_Data;
struct ImGui_ImplSDL2_Data;
struct ImGui_ImplSDL2_ViewportData;
struct ImGui_ImplSDL3_Data;
struct ImGui_ImplSDL3_ViewportData;
struct ImGui_ImplSDLGPU3_Data;
struct ImGui_ImplSDLGPU3_FrameData;
struct ImGui_ImplSDLGPU3_InitInfo;
struct ImGui_ImplSDLGPU3_RenderState;
struct ImGui_ImplSDLRenderer2_Data;
struct ImGui_ImplSDLRenderer2_RenderState;
struct ImGui_ImplSDLRenderer3_Data;
struct ImGui_ImplSDLRenderer3_RenderState;
struct ImGui_ImplStbTrueType_FontSrcData;
struct ImGui_ImplVulkanH_Frame;
struct ImGui_ImplVulkanH_FrameSemaphores;
struct ImGui_ImplVulkanH_Window;
struct ImGui_ImplVulkan_Data;
struct ImGui_ImplVulkan_FrameRenderBuffers;
struct ImGui_ImplVulkan_InitInfo;
struct ImGui_ImplVulkan_PipelineInfo;
struct ImGui_ImplVulkan_RenderState;
struct ImGui_ImplVulkan_Texture;
struct ImGui_ImplVulkan_ViewportData;
struct ImGui_ImplVulkan_WindowRenderBuffers;
struct ImGui_ImplWGPU_CreateSurfaceInfo;
struct ImGui_ImplWGPU_Data;
struct ImGui_ImplWGPU_InitInfo;
struct ImGui_ImplWGPU_RenderState;
struct ImGui_ImplWGPU_Texture;
struct ImGui_ImplWin32_Data;
struct ImGui_ImplWin32_ViewportData;
struct ImNewWrapper;
struct ImPlotAlignmentData;
struct ImPlotAnnotation;
struct ImPlotAnnotationCollection;
struct ImPlotAxis;
struct ImPlotColormapData;
struct ImPlotContext;
struct ImPlotDateTimeSpec;
struct ImPlotInputMap;
struct ImPlotItem;
struct ImPlotItemGroup;
struct ImPlotLegend;
struct ImPlotNextItemData;
struct ImPlotNextPlotData;
struct ImPlotPlot;
struct ImPlotPoint;
struct ImPlotPointError;
struct ImPlotRange;
struct ImPlotRect;
struct ImPlotSpec;
struct ImPlotStyle;
struct ImPlotSubplot;
struct ImPlotTag;
struct ImPlotTagCollection;
struct ImPlotTick;
struct ImPlotTicker;
struct ImPlotTime;

template <typename T>
struct ImPool;

struct ImRect;

template <typename T>
struct ImSpan;

template <int CHUNKS>
struct ImSpanAllocator;

template <typename T, int BLOCKSIZE>
struct ImStableVector;

struct ImTextureData;
struct ImTextureRect;
struct ImTextureRef;
struct ImTriangulator;
struct ImTriangulatorNode;
struct ImTriangulatorNodeSpan;
struct ImVec1;
struct ImVec2;
struct ImVec2i;
struct ImVec2ih;
struct ImVec4;

template <typename T>
struct ImVector;

struct InputTextCallback_UserData;
struct LoadedModules;
struct MyDocument;
struct RenderResources;
struct STB_TexteditState;
struct StbTexteditRow;
struct StbUndoRecord;
struct StbUndoState;
struct Uniforms;
struct VERTEX_CONSTANT_BUFFER_DX10;
struct VERTEX_CONSTANT_BUFFER_DX11;
struct VERTEX_CONSTANT_BUFFER_DX12;
struct WGL_WindowData;
struct errors;

template <class T>
struct is_pair;

template <class T1, class T2>
struct is_pair<std::pair<T1, T2>>;

struct stbrp_context;
struct stbrp_context_opaque;
struct stbrp_node;
struct stbrp_rect;
struct stbtt__bitmap;
struct stbtt__buf;
struct stbtt_aligned_quad;
struct stbtt_bakedchar;
struct stbtt_fontinfo;
struct stbtt_kerningentry;
struct stbtt_pack_context;
struct stbtt_pack_range;
struct stbtt_packedchar;
struct stbtt_vertex;
struct uSynergyContext;
struct uSynergyCookie;

// unions

union ImGL3WProcs;

// classes

template <typename T>
class TraitsTest;

class copy_only_test;

template <typename T>
class custom_allocator;

class deserializer;

template <typename T>
class identity_hash;

template <unsigned int MOD>
class mod_hash;

class move_only_test;
class self_reference_member_test;
class serializer;
class utils;

// global variables

static PyObject* markup;
static PyMethodDef module_methods[];
static struct PyModuleDef module_definition = {   PyModuleDef_HEAD_INIT,  "markupsafe._speedups",     NULL,   -1,     module_methods,  NULL,   NULL,   NULL,   NULL };
constexpr size_t READ_AHEAD_LEN = 10;
constexpr size_t MAX_UNLOAD_LEN = 500;
static const unsigned int mola_icon_width = 64;
static const unsigned int mola_icon_height = 64;
static const char* mola_icon_data;
static std::map<std::string, LoadedModules> loaded_lib_handled;
static std::size_t nb_custom_allocs = 0;
static EGLDisplay g_EglDisplay = EGL_NO_DISPLAY;
static EGLSurface g_EglSurface = EGL_NO_SURFACE;
static EGLContext g_EglContext = EGL_NO_CONTEXT;
static struct android_app* g_App = nullptr;
static bool g_Initialized = false;
static char g_LogTag[] = "ImGuiExample";
static std::string g_IniFilename = "";
static VkAllocationCallbacks* g_Allocator = nullptr;
static VkInstance g_Instance = VK_NULL_HANDLE;
static VkPhysicalDevice g_PhysicalDevice = VK_NULL_HANDLE;
static VkDevice g_Device = VK_NULL_HANDLE;
static uint32_t g_QueueFamily =(uint32_t)-1;
static VkQueue g_Queue = VK_NULL_HANDLE;
static VkPipelineCache g_PipelineCache = VK_NULL_HANDLE;
static VkDescriptorPool g_DescriptorPool = VK_NULL_HANDLE;
static ImGui_ImplVulkanH_Window g_MainWindowData;
static uint32_t g_MinImageCount = 2;
static bool g_SwapChainRebuild = false;
static WGPUInstance wgpu_instance = nullptr;
static WGPUDevice wgpu_device = nullptr;
static WGPUSurface wgpu_surface = nullptr;
static WGPUQueue wgpu_queue = nullptr;
static WGPUSurfaceConfiguration wgpu_surface_configuration = {};
static int wgpu_surface_width = 1280;
static int wgpu_surface_height = 800;
static bool show_demo_window = true;
static bool show_another_window = false;
static ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);
static ID3D11Device* g_pd3dDevice = nullptr;
static ID3D11DeviceContext* g_pd3dDeviceContext = nullptr;
static IDXGISwapChain* g_pSwapChain = nullptr;
static ID3D11RenderTargetView* g_mainRenderTargetView = nullptr;
static VkAllocationCallbacks* g_Allocator = nullptr;
static VkInstance g_Instance = VK_NULL_HANDLE;
static VkPhysicalDevice g_PhysicalDevice = VK_NULL_HANDLE;
static VkDevice g_Device = VK_NULL_HANDLE;
static uint32_t g_QueueFamily =(uint32_t)-1;
static VkQueue g_Queue = VK_NULL_HANDLE;
static VkPipelineCache g_PipelineCache = VK_NULL_HANDLE;
static VkDescriptorPool g_DescriptorPool = VK_NULL_HANDLE;
static ImGui_ImplVulkanH_Window g_MainWindowData;
static uint32_t g_MinImageCount = 2;
static bool g_SwapChainRebuild = false;
static WGPUInstance wgpu_instance = nullptr;
static WGPUDevice wgpu_device = nullptr;
static WGPUSurface wgpu_surface = nullptr;
static WGPUQueue wgpu_queue = nullptr;
static WGPUSurfaceConfiguration wgpu_surface_configuration = {};
static int wgpu_surface_width = 1280;
static int wgpu_surface_height = 800;
static ID3D11Device* g_pd3dDevice = nullptr;
static ID3D11DeviceContext* g_pd3dDeviceContext = nullptr;
static IDXGISwapChain* g_pSwapChain = nullptr;
static ID3D11RenderTargetView* g_mainRenderTargetView = nullptr;
static VkAllocationCallbacks* g_Allocator = nullptr;
static VkInstance g_Instance = VK_NULL_HANDLE;
static VkPhysicalDevice g_PhysicalDevice = VK_NULL_HANDLE;
static VkDevice g_Device = VK_NULL_HANDLE;
static uint32_t g_QueueFamily =(uint32_t)-1;
static VkQueue g_Queue = VK_NULL_HANDLE;
static VkPipelineCache g_PipelineCache = VK_NULL_HANDLE;
static VkDescriptorPool g_DescriptorPool = VK_NULL_HANDLE;
static ImGui_ImplVulkanH_Window g_MainWindowData;
static uint32_t g_MinImageCount = 2;
static bool g_SwapChainRebuild = false;
static WGPUInstance wgpu_instance = nullptr;
static WGPUDevice wgpu_device = nullptr;
static WGPUSurface wgpu_surface = nullptr;
static WGPUQueue wgpu_queue = nullptr;
static WGPUSurfaceConfiguration wgpu_surface_configuration = {};
static int wgpu_surface_width = 1280;
static int wgpu_surface_height = 800;
static ID3D10Device* g_pd3dDevice = nullptr;
static IDXGISwapChain* g_pSwapChain = nullptr;
static bool g_SwapChainOccluded = false;
static UINT g_ResizeWidth = 0;
static UINT g_ResizeHeight = 0;
static ID3D10RenderTargetView* g_mainRenderTargetView = nullptr;
static ID3D11Device* g_pd3dDevice = nullptr;
static ID3D11DeviceContext* g_pd3dDeviceContext = nullptr;
static IDXGISwapChain* g_pSwapChain = nullptr;
static bool g_SwapChainOccluded = false;
static UINT g_ResizeWidth = 0;
static UINT g_ResizeHeight = 0;
static ID3D11RenderTargetView* g_mainRenderTargetView = nullptr;
static const int APP_NUM_FRAMES_IN_FLIGHT = 2;
static const int APP_NUM_BACK_BUFFERS = 2;
static const int APP_SRV_HEAP_SIZE = 64;
static FrameContext g_frameContext[APP_NUM_FRAMES_IN_FLIGHT] = {};
static UINT g_frameIndex = 0;
static ID3D12Device* g_pd3dDevice = nullptr;
static ID3D12DescriptorHeap* g_pd3dRtvDescHeap = nullptr;
static ID3D12DescriptorHeap* g_pd3dSrvDescHeap = nullptr;
static ExampleDescriptorHeapAllocator g_pd3dSrvDescHeapAlloc;
static ID3D12CommandQueue* g_pd3dCommandQueue = nullptr;
static ID3D12GraphicsCommandList* g_pd3dCommandList = nullptr;
static ID3D12Fence* g_fence = nullptr;
static HANDLE g_fenceEvent = nullptr;
static UINT64 g_fenceLastSignaledValue = 0;
static IDXGISwapChain3* g_pSwapChain = nullptr;
static bool g_SwapChainTearingSupport = false;
static bool g_SwapChainOccluded = false;
static HANDLE g_hSwapChainWaitableObject = nullptr;
static ID3D12Resource* g_mainRenderTargetResource[APP_NUM_BACK_BUFFERS] = {};
static D3D12_CPU_DESCRIPTOR_HANDLE g_mainRenderTargetDescriptor[APP_NUM_BACK_BUFFERS] = {};
static LPDIRECT3D9 g_pD3D = nullptr;
static LPDIRECT3DDEVICE9 g_pd3dDevice = nullptr;
static bool g_DeviceLost = false;
static UINT g_ResizeWidth = 0;
static UINT g_ResizeHeight = 0;
static D3DPRESENT_PARAMETERS g_d3dpp = {};
static HGLRC g_hRC;
static WGL_WindowData g_MainWindow;
static int g_Width;
static int g_Height;
static VkAllocationCallbacks* g_Allocator = nullptr;
static VkInstance g_Instance = VK_NULL_HANDLE;
static VkPhysicalDevice g_PhysicalDevice = VK_NULL_HANDLE;
static VkDevice g_Device = VK_NULL_HANDLE;
static uint32_t g_QueueFamily =(uint32_t)-1;
static VkQueue g_Queue = VK_NULL_HANDLE;
static VkDebugReportCallbackEXT g_DebugReport = VK_NULL_HANDLE;
static VkPipelineCache g_PipelineCache = VK_NULL_HANDLE;
static VkDescriptorPool g_DescriptorPool = VK_NULL_HANDLE;
static ImGui_ImplVulkanH_Window g_MainWindowData;
static uint32_t g_MinImageCount = 2;
static bool g_SwapChainRebuild = false;
constexpr size_t HARD_MAX_MATCHES = 3;
const thread_local auto ENV_DO_PROFILE_COV =     mrpt::get_env<bool>("MOLA_KEYFRAME_MAP_PROFILE_COV", false);
const thread_local auto ENV_DEBUG_ACTIVE_KFS =     mrpt::get_env<bool>("MOLA_KEYFRAME_MAP_DEBUG_ACTIVE_KFS", false);
constexpr size_t HARD_MAX_MATCHES = 3;
const std::string datasetsRoot = TEST_DATASETS_ROOT;
static double g_Time = 0.0;
static ANativeWindow* g_Window;
static char g_LogTag[] = "ImGuiExample";
decltype(D3D12SerializeRootSignature) typedef* _PFN_D3D12_SERIALIZE_ROOT_SIGNATURE;
static ImVector<ImGui_ImplGlfw_WindowToContext> g_ContextMap;
static int g_Time = 0;
GL3W_API union ImGL3WProcs imgl3wProcs;
static const Uint32 SDL_WINDOW_VULKAN = 0x10000000;
const uint8_t spirv_vertex[1732] = {     3,2,35,7,0,0,1,0,11,0,13,0,55,0,0,0,0,0,0,0,17,0,2,0,1,0,0,0,11,0,6,0,1,0,0,0,71,76,83,76,46,115,116,100,46,52,53,48,0,0,0,0,14,0,3,0,0,0,0,0,1,0,0,0,15,0,10,0,0,0,0,0,4,0,0,0,109,     97,105,110,0,0,0,0,11,0,0,0,15,0,0,0,21,0,0,0,30,0,0,0,31,0,0,0,3,0,3,0,2,0,0,0,194,1,0,0,4,0,10,0,71,76,95,71,79,79,71,76,69,95,99,112,112,95,115,116,121,108,101,95,108,105,110,101,     95,100,105,114,101,99,116,105,118,101,0,0,4,0,8,0,71,76,95,71,79,79,71,76,69,95,105,110,99,108,117,100,101,95,100,105,114,101,99,116,105,118,101,0,5,0,4,0,4,0,0,0,109,97,105,110,0,     0,0,0,5,0,3,0,9,0,0,0,0,0,0,0,6,0,5,0,9,0,0,0,0,0,0,0,67,111,108,111,114,0,0,0,6,0,4,0,9,0,0,0,1,0,0,0,85,86,0,0,5,0,3,0,11,0,0,0,79,117,116,0,5,0,4,0,15,0,0,0,97,67,111,108,111,114,     0,0,5,0,3,0,21,0,0,0,97,85,86,0,5,0,6,0,28,0,0,0,103,108,95,80,101,114,86,101,114,116,101,120,0,0,0,0,6,0,6,0,28,0,0,0,0,0,0,0,103,108,95,80,111,115,105,116,105,111,110,0,6,0,7,0,28,     0,0,0,1,0,0,0,103,108,95,80,111,105,110,116,83,105,122,101,0,0,0,0,6,0,7,0,28,0,0,0,2,0,0,0,103,108,95,67,108,105,112,68,105,115,116,97,110,99,101,0,6,0,7,0,28,0,0,0,3,0,0,0,103,108,     95,67,117,108,108,68,105,115,116,97,110,99,101,0,5,0,3,0,30,0,0,0,0,0,0,0,5,0,4,0,31,0,0,0,97,80,111,115,0,0,0,0,5,0,6,0,33,0,0,0,117,80,117,115,104,67,111,110,115,116,97,110,116,0,     0,0,6,0,5,0,33,0,0,0,0,0,0,0,117,83,99,97,108,101,0,0,6,0,6,0,33,0,0,0,1,0,0,0,117,84,114,97,110,115,108,97,116,101,0,0,5,0,3,0,35,0,0,0,112,99,0,0,71,0,4,0,11,0,0,0,30,0,0,0,0,0,0,     0,71,0,4,0,15,0,0,0,30,0,0,0,2,0,0,0,71,0,4,0,21,0,0,0,30,0,0,0,1,0,0,0,71,0,3,0,28,0,0,0,2,0,0,0,72,0,5,0,28,0,0,0,0,0,0,0,11,0,0,0,0,0,0,0,72,0,5,0,28,0,0,0,1,0,0,0,11,0,0,0,1,0,     0,0,72,0,5,0,28,0,0,0,2,0,0,0,11,0,0,0,3,0,0,0,72,0,5,0,28,0,0,0,3,0,0,0,11,0,0,0,4,0,0,0,71,0,4,0,31,0,0,0,30,0,0,0,0,0,0,0,71,0,3,0,33,0,0,0,2,0,0,0,72,0,5,0,33,0,0,0,0,0,0,0,35,     0,0,0,0,0,0,0,72,0,5,0,33,0,0,0,1,0,0,0,35,0,0,0,8,0,0,0,71,0,4,0,35,0,0,0,33,0,0,0,0,0,0,0,71,0,4,0,35,0,0,0,34,0,0,0,1,0,0,0,19,0,2,0,2,0,0,0,33,0,3,0,3,0,0,0,2,0,0,0,22,0,3,0,6,     0,0,0,32,0,0,0,23,0,4,0,7,0,0,0,6,0,0,0,4,0,0,0,23,0,4,0,8,0,0,0,6,0,0,0,2,0,0,0,30,0,4,0,9,0,0,0,7,0,0,0,8,0,0,0,32,0,4,0,10,0,0,0,3,0,0,0,9,0,0,0,59,0,4,0,10,0,0,0,11,0,0,0,3,0,0,     0,21,0,4,0,12,0,0,0,32,0,0,0,1,0,0,0,43,0,4,0,12,0,0,0,13,0,0,0,0,0,0,0,32,0,4,0,14,0,0,0,1,0,0,0,7,0,0,0,59,0,4,0,14,0,0,0,15,0,0,0,1,0,0,0,32,0,4,0,17,0,0,0,3,0,0,0,7,0,0,0,43,0,     4,0,12,0,0,0,19,0,0,0,1,0,0,0,32,0,4,0,20,0,0,0,1,0,0,0,8,0,0,0,59,0,4,0,20,0,0,0,21,0,0,0,1,0,0,0,32,0,4,0,23,0,0,0,3,0,0,0,8,0,0,0,21,0,4,0,25,0,0,0,32,0,0,0,0,0,0,0,43,0,4,0,25,     0,0,0,26,0,0,0,1,0,0,0,28,0,4,0,27,0,0,0,6,0,0,0,26,0,0,0,30,0,6,0,28,0,0,0,7,0,0,0,6,0,0,0,27,0,0,0,27,0,0,0,32,0,4,0,29,0,0,0,3,0,0,0,28,0,0,0,59,0,4,0,29,0,0,0,30,0,0,0,3,0,0,0,     59,0,4,0,20,0,0,0,31,0,0,0,1,0,0,0,30,0,4,0,33,0,0,0,8,0,0,0,8,0,0,0,32,0,4,0,34,0,0,0,2,0,0,0,33,0,0,0,59,0,4,0,34,0,0,0,35,0,0,0,2,0,0,0,32,0,4,0,36,0,0,0,2,0,0,0,8,0,0,0,43,0,4,     0,6,0,0,0,43,0,0,0,0,0,0,0,43,0,4,0,6,0,0,0,44,0,0,0,0,0,128,63,43,0,4,0,6,0,0,0,49,0,0,0,0,0,128,191,32,0,4,0,50,0,0,0,3,0,0,0,6,0,0,0,54,0,5,0,2,0,0,0,4,0,0,0,0,0,0,0,3,0,0,0,248,     0,2,0,5,0,0,0,61,0,4,0,7,0,0,0,16,0,0,0,15,0,0,0,65,0,5,0,17,0,0,0,18,0,0,0,11,0,0,0,13,0,0,0,62,0,3,0,18,0,0,0,16,0,0,0,61,0,4,0,8,0,0,0,22,0,0,0,21,0,0,0,65,0,5,0,23,0,0,0,24,0,0,     0,11,0,0,0,19,0,0,0,62,0,3,0,24,0,0,0,22,0,0,0,61,0,4,0,8,0,0,0,32,0,0,0,31,0,0,0,65,0,5,0,36,0,0,0,37,0,0,0,35,0,0,0,13,0,0,0,61,0,4,0,8,0,0,0,38,0,0,0,37,0,0,0,133,0,5,0,8,0,0,0,     39,0,0,0,32,0,0,0,38,0,0,0,65,0,5,0,36,0,0,0,40,0,0,0,35,0,0,0,19,0,0,0,61,0,4,0,8,0,0,0,41,0,0,0,40,0,0,0,129,0,5,0,8,0,0,0,42,0,0,0,39,0,0,0,41,0,0,0,81,0,5,0,6,0,0,0,45,0,0,0,42,     0,0,0,0,0,0,0,81,0,5,0,6,0,0,0,46,0,0,0,42,0,0,0,1,0,0,0,80,0,7,0,7,0,0,0,47,0,0,0,45,0,0,0,46,0,0,0,43,0,0,0,44,0,0,0,65,0,5,0,17,0,0,0,48,0,0,0,30,0,0,0,13,0,0,0,62,0,3,0,48,0,0,     0,47,0,0,0,65,0,6,0,50,0,0,0,51,0,0,0,30,0,0,0,13,0,0,0,26,0,0,0,61,0,4,0,6,0,0,0,52,0,0,0,51,0,0,0,133,0,5,0,6,0,0,0,53,0,0,0,52,0,0,0,49,0,0,0,65,0,6,0,50,0,0,0,54,0,0,0,30,0,0,0,     13,0,0,0,26,0,0,0,62,0,3,0,54,0,0,0,53,0,0,0,253,0,1,0,56,0,1,0, };
const uint8_t spirv_fragment[844] = {     3,2,35,7,0,0,1,0,11,0,13,0,30,0,0,0,0,0,0,0,17,0,2,0,1,0,0,0,11,0,6,0,1,0,0,0,71,76,83,76,46,115,116,100,46,52,53,48,0,0,0,0,14,0,3,0,0,0,0,0,1,0,0,0,15,0,7,0,4,0,0,0,4,0,0,0,109,97,     105,110,0,0,0,0,9,0,0,0,13,0,0,0,16,0,3,0,4,0,0,0,7,0,0,0,3,0,3,0,2,0,0,0,194,1,0,0,4,0,10,0,71,76,95,71,79,79,71,76,69,95,99,112,112,95,115,116,121,108,101,95,108,105,110,101,95,100,     105,114,101,99,116,105,118,101,0,0,4,0,8,0,71,76,95,71,79,79,71,76,69,95,105,110,99,108,117,100,101,95,100,105,114,101,99,116,105,118,101,0,5,0,4,0,4,0,0,0,109,97,105,110,0,0,0,0,5,     0,4,0,9,0,0,0,102,67,111,108,111,114,0,0,5,0,3,0,11,0,0,0,0,0,0,0,6,0,5,0,11,0,0,0,0,0,0,0,67,111,108,111,114,0,0,0,6,0,4,0,11,0,0,0,1,0,0,0,85,86,0,0,5,0,3,0,13,0,0,0,73,110,0,0,5,     0,5,0,22,0,0,0,115,84,101,120,116,117,114,101,0,0,0,0,71,0,4,0,9,0,0,0,30,0,0,0,0,0,0,0,71,0,4,0,13,0,0,0,30,0,0,0,0,0,0,0,71,0,4,0,22,0,0,0,33,0,0,0,0,0,0,0,71,0,4,0,22,0,0,0,34,0,     0,0,2,0,0,0,19,0,2,0,2,0,0,0,33,0,3,0,3,0,0,0,2,0,0,0,22,0,3,0,6,0,0,0,32,0,0,0,23,0,4,0,7,0,0,0,6,0,0,0,4,0,0,0,32,0,4,0,8,0,0,0,3,0,0,0,7,0,0,0,59,0,4,0,8,0,0,0,9,0,0,0,3,0,0,0,23,     0,4,0,10,0,0,0,6,0,0,0,2,0,0,0,30,0,4,0,11,0,0,0,7,0,0,0,10,0,0,0,32,0,4,0,12,0,0,0,1,0,0,0,11,0,0,0,59,0,4,0,12,0,0,0,13,0,0,0,1,0,0,0,21,0,4,0,14,0,0,0,32,0,0,0,1,0,0,0,43,0,4,0,     14,0,0,0,15,0,0,0,0,0,0,0,32,0,4,0,16,0,0,0,1,0,0,0,7,0,0,0,25,0,9,0,19,0,0,0,6,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,27,0,3,0,20,0,0,0,19,0,0,0,32,0,4,0,21,0,0,0,0,     0,0,0,20,0,0,0,59,0,4,0,21,0,0,0,22,0,0,0,0,0,0,0,43,0,4,0,14,0,0,0,24,0,0,0,1,0,0,0,32,0,4,0,25,0,0,0,1,0,0,0,10,0,0,0,54,0,5,0,2,0,0,0,4,0,0,0,0,0,0,0,3,0,0,0,248,0,2,0,5,0,0,0,65,     0,5,0,16,0,0,0,17,0,0,0,13,0,0,0,15,0,0,0,61,0,4,0,7,0,0,0,18,0,0,0,17,0,0,0,61,0,4,0,20,0,0,0,23,0,0,0,22,0,0,0,65,0,5,0,25,0,0,0,26,0,0,0,13,0,0,0,24,0,0,0,61,0,4,0,10,0,0,0,27,0,     0,0,26,0,0,0,87,0,5,0,7,0,0,0,28,0,0,0,23,0,0,0,27,0,0,0,133,0,5,0,7,0,0,0,29,0,0,0,18,0,0,0,28,0,0,0,62,0,3,0,9,0,0,0,29,0,0,0,253,0,1,0,56,0,1,0, };
const uint8_t dxbc_vertex[1064] = {     68,88,66,67,32,50,127,204,241,196,165,104,216,114,216,116,220,164,29,45,1,0,0,0,40,4,0,0,5,0,0,0,52,0,0,0,136,1,0,0,236,1,0,0,92,2,0,0,140,3,0,0,82,68,69,70,76,1,0,0,1,0,0,0,116,0,     0,0,1,0,0,0,60,0,0,0,1,5,254,255,0,5,0,0,34,1,0,0,19,19,68,37,60,0,0,0,24,0,0,0,40,0,0,0,40,0,0,0,36,0,0,0,12,0,0,0,0,0,0,0,100,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,     0,1,0,0,0,1,0,0,0,0,0,0,0,117,80,117,115,104,67,111,110,115,116,97,110,116,0,171,171,100,0,0,0,2,0,0,0,140,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,220,0,0,0,0,0,0,0,8,0,0,0,2,0,0,0,240,0,0,     0,0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0,20,1,0,0,8,0,0,0,8,0,0,0,2,0,0,0,240,0,0,0,0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255,0,0,0,0,112,99,95,117,83,99,97,     108,101,0,102,108,111,97,116,50,0,171,171,171,1,0,3,0,1,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,230,0,0,0,112,99,95,117,84,114,97,110,115,108,97,116,101,0,77,105,99,114,     111,115,111,102,116,32,40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111,109,112,105,108,101,114,32,49,48,46,49,0,171,171,73,83,71,78,92,0,0,0,3,0,0,0,8,0,0,0,80,0,0,0,0,0,     0,0,0,0,0,0,3,0,0,0,0,0,0,0,3,3,0,0,80,0,0,0,1,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0,3,3,0,0,80,0,0,0,2,0,0,0,0,0,0,0,3,0,0,0,2,0,0,0,15,15,0,0,84,69,88,67,79,79,82,68,0,171,171,171,79,83,     71,78,104,0,0,0,3,0,0,0,8,0,0,0,80,0,0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,15,0,0,0,80,0,0,0,1,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0,3,12,0,0,89,0,0,0,0,0,0,0,1,0,0,0,3,0,0,0,2,0,0,0,15,0,0,     0,84,69,88,67,79,79,82,68,0,83,86,95,80,111,115,105,116,105,111,110,0,171,171,171,83,72,69,88,40,1,0,0,81,0,1,0,74,0,0,0,106,8,0,1,89,0,0,7,70,142,48,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,     0,0,1,0,0,0,95,0,0,3,50,16,16,0,0,0,0,0,95,0,0,3,50,16,16,0,1,0,0,0,95,0,0,3,242,16,16,0,2,0,0,0,101,0,0,3,242,32,16,0,0,0,0,0,101,0,0,3,50,32,16,0,1,0,0,0,103,0,0,4,242,32,16,0,2,     0,0,0,1,0,0,0,104,0,0,2,1,0,0,0,50,0,0,13,50,0,16,0,0,0,0,0,70,16,16,0,0,0,0,0,70,128,48,0,0,0,0,0,0,0,0,0,0,0,0,0,230,138,48,0,0,0,0,0,0,0,0,0,0,0,0,0,54,0,0,6,34,32,16,0,2,0,0,0,     26,0,16,128,65,0,0,0,0,0,0,0,54,0,0,5,242,32,16,0,0,0,0,0,70,30,16,0,2,0,0,0,54,0,0,5,18,32,16,0,2,0,0,0,10,0,16,0,0,0,0,0,54,0,0,8,194,32,16,0,2,0,0,0,2,64,0,0,0,0,0,0,0,0,0,0,0,0,     0,0,0,0,128,63,54,0,0,5,50,32,16,0,1,0,0,0,70,16,16,0,1,0,0,0,62,0,0,1,83,84,65,84,148,0,0,0,7,0,0,0,1,0,0,0,0,0,0,0,6,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,     0,0,0,0,0,0,0,0,0,0,0,0,0,0, };
const uint8_t dxbc_fragment[744] = {     68,88,66,67,235,219,43,109,38,151,39,223,98,41,193,28,215,98,67,110,1,0,0,0,232,2,0,0,5,0,0,0,52,0,0,0,12,1,0,0,88,1,0,0,140,1,0,0,76,2,0,0,82,68,69,70,208,0,0,0,0,0,0,0,0,0,0,0,2,     0,0,0,60,0,0,0,1,5,255,255,0,5,0,0,167,0,0,0,19,19,68,37,60,0,0,0,24,0,0,0,40,0,0,0,40,0,0,0,36,0,0,0,12,0,0,0,0,0,0,0,140,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,     0,0,2,0,0,0,0,0,0,0,158,0,0,0,2,0,0,0,5,0,0,0,4,0,0,0,255,255,255,255,0,0,0,0,1,0,0,0,12,0,0,0,2,0,0,0,0,0,0,0,95,115,84,101,120,116,117,114,101,95,115,97,109,112,108,101,114,0,115,     84,101,120,116,117,114,101,0,77,105,99,114,111,115,111,102,116,32,40,82,41,32,72,76,83,76,32,83,104,97,100,101,114,32,67,111,109,112,105,108,101,114,32,49,48,46,49,0,171,73,83,71,78,     68,0,0,0,2,0,0,0,8,0,0,0,56,0,0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,15,15,0,0,56,0,0,0,1,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0,3,3,0,0,84,69,88,67,79,79,82,68,0,171,171,171,79,83,71,78,44,0,     0,0,1,0,0,0,8,0,0,0,32,0,0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,15,0,0,0,83,86,95,84,97,114,103,101,116,0,171,171,83,72,69,88,184,0,0,0,81,0,0,0,46,0,0,0,106,8,0,1,90,0,0,6,70,110,48,     0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,88,24,0,7,70,126,48,0,0,0,0,0,0,0,0,0,0,0,0,0,85,85,0,0,2,0,0,0,98,16,0,3,242,16,16,0,0,0,0,0,98,16,0,3,50,16,16,0,1,0,0,0,101,0,0,3,242,32,16,0,0,     0,0,0,104,0,0,2,1,0,0,0,69,0,0,11,242,0,16,0,0,0,0,0,70,16,16,0,1,0,0,0,70,126,32,0,0,0,0,0,0,0,0,0,0,96,32,0,0,0,0,0,0,0,0,0,56,0,0,7,242,32,16,0,0,0,0,0,70,14,16,0,0,0,0,0,70,30,     16,0,0,0,0,0,62,0,0,1,83,84,65,84,148,0,0,0,3,0,0,0,1,0,0,0,0,0,0,0,3,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, };
static bool g_FunctionsLoaded = true;
static uint32_t __glsl_shader_vert_spv[];
static uint32_t __glsl_shader_frag_spv[] = {     0x07230203,0x00010000,0x00080001,0x0000001e,0x00000000,0x00020011,0x00000001,0x0006000b,     0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001,     0x0007000f,0x00000004,0x00000004,0x6e69616d,0x00000000,0x00000009,0x0000000d,0x00030010,     0x00000004,0x00000007,0x00030003,0x00000002,0x000001c2,0x00040005,0x00000004,0x6e69616d,     0x00000000,0x00040005,0x00000009,0x6c6f4366,0x0000726f,0x00030005,0x0000000b,0x00000000,     0x00050006,0x0000000b,0x00000000,0x6f6c6f43,0x00000072,0x00040006,0x0000000b,0x00000001,     0x00005655,0x00030005,0x0000000d,0x00006e49,0x00050005,0x00000016,0x78655473,0x65727574,     0x00000000,0x00040047,0x00000009,0x0000001e,0x00000000,0x00040047,0x0000000d,0x0000001e,     0x00000000,0x00040047,0x00000016,0x00000022,0x00000000,0x00040047,0x00000016,0x00000021,     0x00000000,0x00020013,0x00000002,0x00030021,0x00000003,0x00000002,0x00030016,0x00000006,     0x00000020,0x00040017,0x00000007,0x00000006,0x00000004,0x00040020,0x00000008,0x00000003,     0x00000007,0x0004003b,0x00000008,0x00000009,0x00000003,0x00040017,0x0000000a,0x00000006,     0x00000002,0x0004001e,0x0000000b,0x00000007,0x0000000a,0x00040020,0x0000000c,0x00000001,     0x0000000b,0x0004003b,0x0000000c,0x0000000d,0x00000001,0x00040015,0x0000000e,0x00000020,     0x00000001,0x0004002b,0x0000000e,0x0000000f,0x00000000,0x00040020,0x00000010,0x00000001,     0x00000007,0x00090019,0x00000013,0x00000006,0x00000001,0x00000000,0x00000000,0x00000000,     0x00000001,0x00000000,0x0003001b,0x00000014,0x00000013,0x00040020,0x00000015,0x00000000,     0x00000014,0x0004003b,0x00000015,0x00000016,0x00000000,0x0004002b,0x0000000e,0x00000018,     0x00000001,0x00040020,0x00000019,0x00000001,0x0000000a,0x00050036,0x00000002,0x00000004,     0x00000000,0x00000003,0x000200f8,0x00000005,0x00050041,0x00000010,0x00000011,0x0000000d,     0x0000000f,0x0004003d,0x00000007,0x00000012,0x00000011,0x0004003d,0x00000014,0x00000017,     0x00000016,0x00050041,0x00000019,0x0000001a,0x0000000d,0x00000018,0x0004003d,0x0000000a,     0x0000001b,0x0000001a,0x00050057,0x00000007,0x0000001c,0x00000017,0x0000001b,0x00050085,     0x00000007,0x0000001d,0x00000012,0x0000001c,0x0003003e,0x00000009,0x0000001d,0x000100fd,     0x00010038 };
static const char __shader_vert_wgsl[] = R"(struct VertexInput {     @location(0) position: vec2<f32>,     @location(1) uv: vec2<f32>,     @location(2) color: vec4<f32>, };  struct VertexOutput {     @builtin(position) position: vec4<f32>,     @location(0) color: vec4<f32>,     @location(1) uv: vec2<f32>, };  struct Uniforms {     mvp: mat4x4<f32>,     gamma: f32, };  @group(0) @binding(0) var<uniform> uniforms: Uniforms;  @vertex fn main(in: VertexInput) -> VertexOutput {     var out: VertexOutput;     out.position = uniforms.mvp* vec4<f32>(in.position, 0.0, 1.0);     out.color = in.color;     out.uv = in.uv;     return out; })";
static const char __shader_frag_wgsl[] = R"(struct VertexOutput {     @builtin(position) position: vec4<f32>,     @location(0) color: vec4<f32>,     @location(1) uv: vec2<f32>, };  struct Uniforms {     mvp: mat4x4<f32>,     gamma: f32, };  @group(0) @binding(0) var<uniform> uniforms: Uniforms; @group(0) @binding(1) var s: sampler; @group(1) @binding(0) var t: texture_2d<f32>;  @fragment fn main(in: VertexOutput) -> @location(0) vec4<f32> {     let color = in.color* textureSample(t, s, in.uv);     let corrected_color = pow(color.rgb, vec3<f32>(uniforms.gamma));     return vec4<f32>(corrected_color, color.a); })";
static const float FONT_DEFAULT_SIZE_BASE = 20.0f;
static const float NAV_WINDOWING_HIGHLIGHT_DELAY = 0.20f;
static const float NAV_WINDOWING_LIST_APPEAR_DELAY = 0.15f;
static const float NAV_ACTIVATE_HIGHLIGHT_TIMER = 0.10f;
static const float WINDOWS_RESIZE_FROM_EDGES_FEEDBACK_TIMER = 0.04f;
static const float WINDOWS_MOUSE_WHEEL_SCROLL_LOCK_TIMER = 0.70f;
static const ImVec2 TOOLTIP_DEFAULT_OFFSET_MOUSE = ImVec2(16, 10);
static const ImVec2 TOOLTIP_DEFAULT_OFFSET_TOUCH = ImVec2(0, -20);
static const ImVec2 TOOLTIP_DEFAULT_PIVOT_TOUCH = ImVec2(0.5f, 1.0f);
static const float DOCKING_TRANSPARENT_PAYLOAD_ALPHA = 0.50f;
ImGuiContext* GImGui = NULL;
static ImGuiMemAllocFunc GImAllocatorAllocFunc = MallocWrapper;
static ImGuiMemFreeFunc GImAllocatorFreeFunc = FreeWrapper;
static void* GImAllocatorUserData = NULL;
static const ImU32 GCrc32LookupTable[256];
static const ImGuiCol GWindowDockStyleColors[ImGuiWindowDockStyleCol_COUNT] = {     ImGuiCol_Text, ImGuiCol_TabHovered, ImGuiCol_Tab, ImGuiCol_TabSelected, ImGuiCol_TabSelectedOverline, ImGuiCol_TabDimmed, ImGuiCol_TabDimmedSelected, ImGuiCol_TabDimmedSelectedOverline, ImGuiCol_UnsavedMarker, };
static const ImGuiStyleVarInfo GStyleVarsInfo[];
static const ImGuiLocEntry GLocalizationEntriesEnUS[] = {     { ImGuiLocKey_VersionStr,           "Dear ImGui " IMGUI_VERSION "(" IM_STRINGIFY(IMGUI_VERSION_NUM) ")" },     { ImGuiLocKey_TableSizeOne,         "Size column to fit###SizeOne"          },     { ImGuiLocKey_TableSizeAllFit,      "Size all columns to fit###SizeAll"     },     { ImGuiLocKey_TableSizeAllDefault,  "Size all columns to default###SizeAll" },     { ImGuiLocKey_TableResetOrder,      "Reset order###ResetOrder"              },     { ImGuiLocKey_WindowingMainMenuBar, "(Main menu bar)"                       },     { ImGuiLocKey_WindowingPopup,       "(Popup)"                               },     { ImGuiLocKey_WindowingUntitled,    "(Untitled)"                            },     { ImGuiLocKey_OpenLink_s,           "Open '%s'"                             },     { ImGuiLocKey_CopyLink,             "Copy Link###CopyLink"                  },     { ImGuiLocKey_DockingHideTabBar,            "Hide tab bar###HideTabBar"             },     { ImGuiLocKey_DockingHoldShiftToDock,       "Hold SHIFT to enable Docking window."  },     { ImGuiLocKey_DockingDragToUndockOrMoveNode,"Click and drag to move or undock whole node."    }, };
static const ImGuiResizeGripDef resize_grip_def[4] = {     { ImVec2(1, 1), ImVec2(-1, -1), 0, 3 },       { ImVec2(0, 1), ImVec2(+1, -1), 3, 6 },       { ImVec2(0, 0), ImVec2(+1, +1), 6, 9 },       { ImVec2(1, 0), ImVec2(-1, +1), 9, 12 }   };
static const ImGuiResizeBorderDef resize_border_def[4] = {     { ImVec2(+1, 0), ImVec2(0, 1), ImVec2(0, 0), IM_PI* 1.00f },      { ImVec2(-1, 0), ImVec2(1, 0), ImVec2(1, 1), IM_PI* 0.00f },      { ImVec2(0, +1), ImVec2(0, 0), ImVec2(1, 0), IM_PI* 1.50f },      { ImVec2(0, -1), ImVec2(1, 1), ImVec2(0, 1), IM_PI* 0.50f }   };
static const char*const GKeyNames[] = {     "Tab", "LeftArrow", "RightArrow", "UpArrow", "DownArrow", "PageUp", "PageDown",     "Home", "End", "Insert", "Delete", "Backspace", "Space", "Enter", "Escape",     "LeftCtrl", "LeftShift", "LeftAlt", "LeftSuper", "RightCtrl", "RightShift", "RightAlt", "RightSuper", "Menu",     "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H",     "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",     "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11", "F12",     "F13", "F14", "F15", "F16", "F17", "F18", "F19", "F20", "F21", "F22", "F23", "F24",     "Apostrophe", "Comma", "Minus", "Period", "Slash", "Semicolon", "Equal", "LeftBracket",     "Backslash", "RightBracket", "GraveAccent", "CapsLock", "ScrollLock", "NumLock", "PrintScreen",     "Pause", "Keypad0", "Keypad1", "Keypad2", "Keypad3", "Keypad4", "Keypad5", "Keypad6",     "Keypad7", "Keypad8", "Keypad9", "KeypadDecimal", "KeypadDivide", "KeypadMultiply",     "KeypadSubtract", "KeypadAdd", "KeypadEnter", "KeypadEqual",     "AppBack", "AppForward", "Oem102",     "GamepadStart", "GamepadBack",     "GamepadFaceLeft", "GamepadFaceRight", "GamepadFaceUp", "GamepadFaceDown",     "GamepadDpadLeft", "GamepadDpadRight", "GamepadDpadUp", "GamepadDpadDown",     "GamepadL1", "GamepadR1", "GamepadL2", "GamepadR2", "GamepadL3", "GamepadR3",     "GamepadLStickLeft", "GamepadLStickRight", "GamepadLStickUp", "GamepadLStickDown",     "GamepadRStickLeft", "GamepadRStickRight", "GamepadRStickUp", "GamepadRStickDown",     "MouseLeft", "MouseRight", "MouseMiddle", "MouseX1", "MouseX2", "MouseWheelX", "MouseWheelY",     "ModCtrl", "ModShift", "ModAlt", "ModSuper",  };
static const ImU32 DEBUG_LOCATE_ITEM_COLOR = IM_COL32(0, 255, 0, 255);
enum ImGuiDir int enum ImGuiKey int enum ImGuiMouseSource int enum ImGuiSortDirection ImU8 typedef int ImGuiCol typedef int ImGuiCond typedef int ImGuiDataType typedef int ImGuiMouseButton typedef int ImGuiMouseCursor typedef int ImGuiStyleVar typedef int ImGuiTableBgTarget typedef int ImDrawFlags typedef int ImDrawListFlags typedef int ImDrawTextFlags typedef int ImFontFlags typedef int ImFontAtlasFlags typedef int ImGuiBackendFlags typedef int ImGuiButtonFlags typedef int ImGuiChildFlags typedef int ImGuiColorEditFlags typedef int ImGuiConfigFlags typedef int ImGuiComboFlags typedef int ImGuiDockNodeFlags typedef int ImGuiDragDropFlags typedef int ImGuiFocusedFlags typedef int ImGuiHoveredFlags typedef int ImGuiInputFlags typedef int ImGuiInputTextFlags typedef int ImGuiItemFlags typedef int ImGuiKeyChord typedef int ImGuiListClipperFlags typedef int ImGuiPopupFlags typedef int ImGuiMultiSelectFlags typedef int ImGuiSelectableFlags typedef int ImGuiSliderFlags typedef int ImGuiTabBarFlags typedef int ImGuiTabItemFlags typedef int ImGuiTableFlags typedef int ImGuiTableColumnFlags typedef int ImGuiTableRowFlags typedef int ImGuiTreeNodeFlags typedef int ImGuiViewportFlags typedef int ImGuiWindowFlags typedef unsigned int ImWchar32 typedef unsigned short ImWchar16 typedef ImWchar16 ImWchar typedef ImS64 ImGuiSelectionUserData typedef int(* ImGuiInputTextCallback)(ImGuiInputTextCallbackData *data);
IM_MSVC_RUNTIME_CHECKS_RESTORE typedef ImU64 ImTextureID;
static const ExampleMemberInfo ExampleTreeNodeMemberInfos[] {     { "MyName",     ImGuiDataType_String,  1, offsetof(ExampleTreeNode, Name) },     { "MyBool",     ImGuiDataType_Bool,    1, offsetof(ExampleTreeNode, DataMyBool) },     { "MyInt",      ImGuiDataType_S32,     1, offsetof(ExampleTreeNode, DataMyInt) },     { "MyVec2",     ImGuiDataType_Float,   2, offsetof(ExampleTreeNode, DataMyVec2) }, };
static const char* ExampleNames[] = {     "Artichoke", "Arugula", "Asparagus", "Avocado", "Bamboo Shoots", "Bean Sprouts", "Beans", "Beet", "Belgian Endive", "Bell Pepper",     "Bitter Gourd", "Bok Choy", "Broccoli", "Brussels Sprouts", "Burdock Root", "Cabbage", "Calabash", "Capers", "Carrot", "Cassava",     "Cauliflower", "Celery", "Celery Root", "Celcuce", "Chayote", "Chinese Broccoli", "Corn", "Cucumber" };
const int FONT_ATLAS_DEFAULT_TEX_DATA_W = 122;
const int FONT_ATLAS_DEFAULT_TEX_DATA_H = 27;
static const char FONT_ATLAS_DEFAULT_TEX_DATA_PIXELS[FONT_ATLAS_DEFAULT_TEX_DATA_W *FONT_ATLAS_DEFAULT_TEX_DATA_H+1] = {     "..-         -XXXXXXX-    X    -           X           -XXXXXXX          -          XXXXXXX-     XX          - XX       XX "     "..-         -X.....X-   X.X   -          X.X          -X.....X          -          X.....X-    X..X         -X..X     X..X"     "---         -XXX.XXX-  X...X  -         X...X         -X....X           -           X....X-    X..X         -X...X   X...X"     "X           -  X.X  - X.....X -        X.....X        -X...X            -            X...X-    X..X         - X...X X...X "     "XX          -  X.X  -X.......X-       X.......X       -X..X.X           -           X.X..X-    X..X         -  X...X...X  "     "X.X         -  X.X  -XXXX.XXXX-       XXXX.XXXX       -X.X X.X          -          X.X X.X-    X..XXX       -   X.....X   "     "X..X        -  X.X  -   X.X   -          X.X          -XX   X.X         -         X.X   XX-    X..X..XXX    -    X...X    "     "X...X       -  X.X  -   X.X   -    XX    X.X    XX    -      X.X        -        X.X      -    X..X..X..XX  -     X.X     "     "X....X      -  X.X  -   X.X   -   X.X    X.X    X.X   -       X.X       -       X.X       -    X..X..X..X.X -    X...X    "     "X.....X     -  X.X  -   X.X   -  X..X    X.X    X..X  -        X.X      -      X.X        -XXX X..X..X..X..X-   X.....X   "     "X......X    -  X.X  -   X.X   - X...XXXXXX.XXXXXX...X -         X.X   XX-XX   X.X         -X..XX........X..X-  X...X...X  "     "X.......X   -  X.X  -   X.X   -X.....................X-          X.X X.X-X.X X.X          -X...X...........X- X...X X...X "     "X........X  -  X.X  -   X.X   - X...XXXXXX.XXXXXX...X -           X.X..X-X..X.X           - X..............X-X...X   X...X"     "X.........X -XXX.XXX-   X.X   -  X..X    X.X    X..X  -            X...X-X...X            -  X.............X-X..X     X..X"     "X..........X-X.....X-   X.X   -   X.X    X.X    X.X   -           X....X-X....X           -  X.............X- XX       XX "     "X......XXXXX-XXXXXXX-   X.X   -    XX    X.X    XX    -          X.....X-X.....X          -   X............X--------------"     "X...X..X    ---------   X.X   -          X.X          -          XXXXXXX-XXXXXXX          -   X...........X -             "     "X..X X..X   -       -XXXX.XXXX-       XXXX.XXXX       -------------------------------------    X..........X -             "     "X.X  X..X   -       -X.......X-       X.......X       -    XX           XX    -           -    X..........X -             "     "XX    X..X  -       - X.....X -        X.....X        -   X.X           X.X   -           -     X........X  -             "     "      X..X  -       -  X...X  -         X...X         -  X..X           X..X  -           -     X........X  -             "     "       XX   -       -   X.X   -          X.X          - X...XXXXXXXXXXXXX...X -           -     XXXXXXXXXX  -             "     "-------------       -    X    -           X           -X.....................X-           -------------------             "     "                    ----------------------------------- X...XXXXXXXXXXXXX...X -                                           "     "                                                      -  X..X           X..X  -                                           "     "                                                      -   X.X           X.X   -                                           "     "                                                      -    XX           XX    -                                           " };
static const ImVec2 FONT_ATLAS_DEFAULT_TEX_CURSOR_DATA[ImGuiMouseCursor_COUNT][3] = {          { ImVec2(0,3), ImVec2(12,19), ImVec2(0, 0) },      { ImVec2(13,0), ImVec2(7,16), ImVec2(1, 8) },      { ImVec2(31,0), ImVec2(23,23), ImVec2(11,11) },      { ImVec2(21,0), ImVec2(9,23), ImVec2(4,11) },      { ImVec2(55,18),ImVec2(23, 9), ImVec2(11, 4) },      { ImVec2(73,0), ImVec2(17,17), ImVec2(8, 8) },      { ImVec2(55,0), ImVec2(17,17), ImVec2(8, 8) },      { ImVec2(91,0), ImVec2(17,22), ImVec2(5, 0) },      { ImVec2(0,3),  ImVec2(12,19), ImVec2(0, 0) },       { ImVec2(0,3),  ImVec2(12,19), ImVec2(0, 0) },       { ImVec2(109,0),ImVec2(13,15), ImVec2(6, 7) },  };
static ImU32 g_CharClassifierIsSeparator_0000_007f[128/16] = {};
static ImU32 g_CharClassifierIsSeparator_3000_300f[16/16] = {};
static unsigned char* stb__barrier_out_e;
static unsigned char* stb__barrier_out_b;
static const unsigned char* stb__barrier_in_b;
static unsigned char* stb__dout;
static const unsigned int proggy_clean_ttf_compressed_size = 9583;
static const unsigned char proggy_clean_ttf_compressed_data[9583];
static const unsigned int proggy_forever_minimal_ttf_compressed_size = 14562;
static const unsigned char proggy_forever_minimal_ttf_compressed_data[14562];
static const int TABLE_DRAW_CHANNEL_BG0 = 0;
static const int TABLE_DRAW_CHANNEL_BG2_FROZEN = 1;
static const int TABLE_DRAW_CHANNEL_NOCLIP = 2;
static const float TABLE_BORDER_SIZE = 1.0f;
static const float TABLE_RESIZE_SEPARATOR_HALF_THICKNESS = 4.0f;
static const float TABLE_RESIZE_SEPARATOR_FEEDBACK_TIMER = 0.06f;
static const float COLUMNS_HIT_RECT_HALF_THICKNESS = 4.0f;
static const float DRAGDROP_HOLD_TO_OPEN_TIMER = 0.70f;
static const float DRAG_MOUSE_THRESHOLD_FACTOR = 0.50f;
static const signed char IM_S8_MIN = -128;
static const signed char IM_S8_MAX = 127;
static const unsigned char IM_U8_MIN = 0;
static const unsigned char IM_U8_MAX = 0xFF;
static const signed short IM_S16_MIN = -32768;
static const signed short IM_S16_MAX = 32767;
static const unsigned short IM_U16_MIN = 0;
static const unsigned short IM_U16_MAX = 0xFFFF;
static const ImS32 IM_S32_MIN = INT_MIN;
static const ImS32 IM_S32_MAX = INT_MAX;
static const ImU32 IM_U32_MIN = 0;
static const ImU32 IM_U32_MAX = UINT_MAX;
static const ImS64 IM_S64_MIN = -9223372036854775807LL - 1;
static const ImS64 IM_S64_MAX = 9223372036854775807LL;
static const ImU64 IM_U64_MIN = 0;
static const ImU64 IM_U64_MAX =(2ULL* 9223372036854775807LL + 1);
static const ImU32 GDefaultRgbaColorMarkers[4] = {     IM_COL32(240,20,20,255), IM_COL32(20,240,20,255), IM_COL32(20,20,240,255), IM_COL32(140,140,140,255) };
static const ImGuiDataTypeInfo GDataTypeInfo[] = {     { sizeof(char),             "S8",   "%d",   "%d"    },       { sizeof(unsigned char),    "U8",   "%u",   "%u"    },     { sizeof(short),            "S16",  "%d",   "%d"    },       { sizeof(unsigned short),   "U16",  "%u",   "%u"    },     { sizeof(int),              "S32",  "%d",   "%d"    },       { sizeof(unsigned int),     "U32",  "%u",   "%u"    },         { sizeof(ImS64),            "S64",  "%lld", "%lld"  },       { sizeof(ImU64),            "U64",  "%llu", "%llu"  },      { sizeof(float),            "float", "%.3f","%f"    },       { sizeof(double),           "double","%f",  "%lf"   },       { sizeof(bool),             "bool", "%d",   "%d"    },       { 0,                        "char*","%s",   "%s"    },   };
static stb_uchar* stb__out;
static FILE* stb__outfile;
static stb_uint stb__outbytes;
static int stb__window = 0x40000;
static stb_uint stb__hashsize = 32768;
static unsigned int stb__running_adler;
static void*(* GImGuiFreeTypeAllocFunc)(size_t size, void *user_data) = ImGuiFreeTypeDefaultAllocFunc;
static void(* GImGuiFreeTypeFreeFunc)(void *ptr, void *user_data) = ImGuiFreeTypeDefaultFreeFunc;
static void* GImGuiFreeTypeAllocatorUserData = nullptr;
ImPlotContext* GImPlot = nullptr;
constexpr int IMPLOT_AUTO = -1;
constexpr ImVec4 IMPLOT_AUTO_COL = ImVec4(0,0,0,-1);
constexpr double IMPLOT_MIN_TIME = 0;
constexpr double IMPLOT_MAX_TIME = 32503680000;
constexpr const char* IMPLOT_LABEL_FORMAT = "%g";
constexpr int IMPLOT_LABEL_MAX_SIZE = 32;
constexpr int IMPLOT_NUM_X_AXES = ImAxis_Y1;
constexpr int IMPLOT_NUM_Y_AXES = ImAxis_COUNT - IMPLOT_NUM_X_AXES;
IMPLOT_API ImPlotContext* GImPlot;
const float lengths[] = {100, 200, 300, 400, 500, 600, 700, 800};
const int32_t num_lengths = 8;
constexpr size_t MAX_UNLOAD_LEN = 250;
constexpr size_t MAX_UNLOAD_LEN = 250;
constexpr size_t MAX_UNLOAD_LEN = 250;

// global functions

static int init_constants(void);
static PyObject* escape_unicode_kind1(PyUnicodeObject* in);
static PyObject* escape_unicode_kind2(PyUnicodeObject* in);
static PyObject* escape_unicode_kind4(PyUnicodeObject* in);
static PyObject* escape_unicode(PyUnicodeObject* in);

static PyObject* escape(
    PyObject* self,
    PyObject* text
    );

static PyObject* escape_silent(
    PyObject* self,
    PyObject* text
    );

static PyObject* soft_str(
    PyObject* self,
    PyObject* s
    );

PyMODINIT_FUNC PyInit__speedups(void);
MRPT_INITIALIZER(do_register_InputROS2);
MRPT_INITIALIZER(do_register_BinFileDataset);
MRPT_INITIALIZER(do_register_RawlogDataset);
MRPT_INITIALIZER(do_register_Rosbag2Dataset);
MRPT_FILL_ENUM(mola::InputMode::ImageDirectory);
MRPT_FILL_ENUM(mola::InputMode::VideoFile);
MRPT_FILL_ENUM(mola::InputMode::LiveCamera);
MRPT_INITIALIZER(register_VideoDataset);
MRPT_INITIALIZER(do_register_mola_kernel);
MRPT_INITIALIZER(do_register_mola_metric_maps);
MRPT_INITIALIZER(do_register_navstate_fuse);
MRPT_INITIALIZER(do_register_navstate_fuse);
MRPT_INITIALIZER(do_register_navstate_fuse);
int main();

int main(
    int argc,
    char** argv
    );

int main(
    int argc,
    char** argv
    );

int main(
    int argc,
    char** argv
    );

const std::map<std::string, LoadedModules>& get_loaded_modules();
void internal_load_lib_modules(mrpt::system::COutputLogger& app, const std::vector<std::string>& lib_search_paths);
static void internal_unload_lib_modules();
void internal_load_lib_modules(mrpt::system::COutputLogger& app, const std::vector<std::string>& lib_search_paths);
const std::map<std::string, LoadedModules>& get_loaded_modules();

template <class T, class U>
bool operator == (
    const custom_allocator<T>&,
    const custom_allocator<U>&
    );

template <class T, class U>
bool operator != (
    const custom_allocator<T>&,
    const custom_allocator<U>&
    );

BOOST_AUTO_TEST_CASE(test_custom_allocator_1);

void run_ini2mm(
    const std::string& filInput,
    const std::string& filIni,
    const std::string& filOutput,
    const std::string& plugins
    );

int main(
    int argc,
    char** argv
    );

int main(
    int argc,
    char** argv
    );

int main(
    int argc,
    char** argv
    );

void run_mm2ini(
    const std::string& filInput,
    const std::string& filOutput,
    const std::string& plugins
    );

int main(
    int argc,
    char** argv
    );

int main(
    int,
    char**
    );

static void Init(struct android_app* app);
static void Shutdown();
static void MainLoopStep();
static int ShowSoftKeyboardInput();
static int PollUnicodeChars();

static int GetAssetData(
    const char* filename,
    void** out_data
    );

static void handleAppCmd(
    struct android_app* app,
    int32_t appCmd
    );

static int32_t handleInputEvent(
    struct android_app* app,
    AInputEvent* inputEvent
    );

void android_main(struct android_app* app);

static void glfw_error_callback(
    int error,
    const char* description
    );

int main(
    int,
    char**
    );

static void glfw_error_callback(
    int error,
    const char* description
    );

int main(
    int,
    char**
    );

static void glfw_error_callback(
    int error,
    const char* description
    );

static void check_vk_result(VkResult err);

static bool IsExtensionAvailable(
    const ImVector<VkExtensionProperties>& properties,
    const char* extension
    );

static void SetupVulkan(ImVector<const char*> instance_extensions);

static void SetupVulkanWindow(
    ImGui_ImplVulkanH_Window* wd,
    VkSurfaceKHR surface,
    int width,
    int height
    );

static void CleanupVulkan();
static void CleanupVulkanWindow(ImGui_ImplVulkanH_Window* wd);

static void FrameRender(
    ImGui_ImplVulkanH_Window* wd,
    ImDrawData* draw_data
    );

static void FramePresent(ImGui_ImplVulkanH_Window* wd);

int main(
    int,
    char**
    );

static bool InitWGPU(GLFWwindow* window);

WGPUSurface CreateWGPUSurface(
    const WGPUInstance& instance,
    GLFWwindow* window
    );

static void glfw_error_callback(
    int error,
    const char* description
    );

static void ResizeSurface(
    int width,
    int height
    );

int main(
    int,
    char**
    );

void MainLoopStep();

int main(
    int argc,
    char** argv
    );

int main(
    int,
    char**
    );

bool CreateDeviceD3D(HWND hWnd);
void CleanupDeviceD3D();
void CreateRenderTarget();
void CleanupRenderTarget();

int main(
    int,
    char**
    );

int main(
    int,
    char**
    );

int main(
    int,
    char**
    );

int main(
    int,
    char**
    );

static void check_vk_result(VkResult err);

static bool IsExtensionAvailable(
    const ImVector<VkExtensionProperties>& properties,
    const char* extension
    );

static void SetupVulkan(ImVector<const char*> instance_extensions);

static void SetupVulkanWindow(
    ImGui_ImplVulkanH_Window* wd,
    VkSurfaceKHR surface,
    int width,
    int height
    );

static void CleanupVulkan();
static void CleanupVulkanWindow(ImGui_ImplVulkanH_Window* wd);

static void FrameRender(
    ImGui_ImplVulkanH_Window* wd,
    ImDrawData* draw_data
    );

static void FramePresent(ImGui_ImplVulkanH_Window* wd);

int main(
    int,
    char**
    );

static bool InitWGPU(SDL_Window* window);

WGPUSurface CreateWGPUSurface(
    const WGPUInstance& instance,
    SDL_Window* window
    );

static void ResizeSurface(
    int width,
    int height
    );

int main(
    int,
    char**
    );

bool CreateDeviceD3D(HWND hWnd);
void CleanupDeviceD3D();
void CreateRenderTarget();
void CleanupRenderTarget();

int main(
    int,
    char**
    );

int main(
    int,
    char**
    );

int main(
    int,
    char**
    );

int main(
    int,
    char**
    );

static void check_vk_result(VkResult err);

static bool IsExtensionAvailable(
    const ImVector<VkExtensionProperties>& properties,
    const char* extension
    );

static void SetupVulkan(ImVector<const char*> instance_extensions);

static void SetupVulkanWindow(
    ImGui_ImplVulkanH_Window* wd,
    VkSurfaceKHR surface,
    int width,
    int height
    );

static void CleanupVulkan();
static void CleanupVulkanWindow(ImGui_ImplVulkanH_Window* wd);

static void FrameRender(
    ImGui_ImplVulkanH_Window* wd,
    ImDrawData* draw_data
    );

static void FramePresent(ImGui_ImplVulkanH_Window* wd);

int main(
    int,
    char**
    );

static bool InitWGPU(SDL_Window* window);

WGPUSurface CreateWGPUSurface(
    const WGPUInstance& instance,
    SDL_Window* window
    );

static void ResizeSurface(
    int width,
    int height
    );

int main(
    int,
    char**
    );

bool CreateDeviceD3D(HWND hWnd);
void CleanupDeviceD3D();
void CreateRenderTarget();
void CleanupRenderTarget();

LRESULT WINAPI WndProc(
    HWND hWnd,
    UINT msg,
    WPARAM wParam,
    LPARAM lParam
    );

int main(
    int,
    char**
    );

IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(
    HWND hWnd,
    UINT msg,
    WPARAM wParam,
    LPARAM lParam
    );

bool CreateDeviceD3D(HWND hWnd);
void CleanupDeviceD3D();
void CreateRenderTarget();
void CleanupRenderTarget();

LRESULT WINAPI WndProc(
    HWND hWnd,
    UINT msg,
    WPARAM wParam,
    LPARAM lParam
    );

int main(
    int,
    char**
    );

IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(
    HWND hWnd,
    UINT msg,
    WPARAM wParam,
    LPARAM lParam
    );

bool CreateDeviceD3D(HWND hWnd);
void CleanupDeviceD3D();
void CreateRenderTarget();
void CleanupRenderTarget();
void WaitForPendingOperations();
FrameContext* WaitForNextFrameContext();

LRESULT WINAPI WndProc(
    HWND hWnd,
    UINT msg,
    WPARAM wParam,
    LPARAM lParam
    );

int main(
    int,
    char**
    );

IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(
    HWND hWnd,
    UINT msg,
    WPARAM wParam,
    LPARAM lParam
    );

bool CreateDeviceD3D(HWND hWnd);
void CleanupDeviceD3D();
void ResetDevice();

LRESULT WINAPI WndProc(
    HWND hWnd,
    UINT msg,
    WPARAM wParam,
    LPARAM lParam
    );

int main(
    int,
    char**
    );

IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(
    HWND hWnd,
    UINT msg,
    WPARAM wParam,
    LPARAM lParam
    );

bool CreateDeviceWGL(
    HWND hWnd,
    WGL_WindowData* data
    );

void CleanupDeviceWGL(
    HWND hWnd,
    WGL_WindowData* data
    );

void ResetDeviceWGL();

LRESULT WINAPI WndProc(
    HWND hWnd,
    UINT msg,
    WPARAM wParam,
    LPARAM lParam
    );

static void Hook_Renderer_CreateWindow(ImGuiViewport* viewport);
static void Hook_Renderer_DestroyWindow(ImGuiViewport* viewport);

static void Hook_Platform_RenderWindow(
    ImGuiViewport* viewport,
    void*
    );

static void Hook_Renderer_SwapBuffers(
    ImGuiViewport* viewport,
    void*
    );

int main(
    int,
    char**
    );

IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(
    HWND hWnd,
    UINT msg,
    WPARAM wParam,
    LPARAM lParam
    );

static void check_vk_result(VkResult err);

static bool IsExtensionAvailable(
    const ImVector<VkExtensionProperties>& properties,
    const char* extension
    );

static void SetupVulkan(ImVector<const char*> instance_extensions);

static void SetupVulkanWindow(
    ImGui_ImplVulkanH_Window* wd,
    VkSurfaceKHR surface,
    int width,
    int height
    );

static void CleanupVulkan();
static void CleanupVulkanWindow(ImGui_ImplVulkanH_Window* wd);

static void FrameRender(
    ImGui_ImplVulkanH_Window* wd,
    ImDrawData* draw_data
    );

static void FramePresent(ImGui_ImplVulkanH_Window* wd);

LRESULT WINAPI WndProc(
    HWND hWnd,
    UINT msg,
    WPARAM wParam,
    LPARAM lParam
    );

static int ImGui_ImplWin32_CreateVkSurface(
    ImGuiViewport* viewport,
    ImU64 vk_instance,
    const void* vk_allocator,
    ImU64* out_vk_surface
    );

int main(
    int,
    char**
    );

IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(
    HWND hWnd,
    UINT msg,
    WPARAM wParam,
    LPARAM lParam
    );

void glfw_error_callback(
    int error,
    const char* description
    );

int main();

BOOST_AUTO_TEST_CASE_TEMPLATE(
    test_policy,
    Policy,
    test_types
    );

BOOST_AUTO_TEST_CASE_TEMPLATE(
    test_policy_min_bucket_count,
    Policy,
    test_types
    );

BOOST_AUTO_TEST_CASE_TEMPLATE(
    test_policy_max_bucket_count,
    Policy,
    test_types
    );

BOOST_AUTO_TEST_CASE_TEMPLATE(test_insert, HMap, test_types);
BOOST_AUTO_TEST_CASE(test_range_insert);
BOOST_AUTO_TEST_CASE(test_rehash_0);
BOOST_AUTO_TEST_CASE(test_insert_with_hint);
BOOST_AUTO_TEST_CASE(test_emplace_hint);
BOOST_AUTO_TEST_CASE(test_emplace);
BOOST_AUTO_TEST_CASE(test_try_emplace);
BOOST_AUTO_TEST_CASE(test_try_emplace_2);
BOOST_AUTO_TEST_CASE(test_try_emplace_hint);
BOOST_AUTO_TEST_CASE(test_insert_or_assign);
BOOST_AUTO_TEST_CASE(test_insert_or_assign_hint);
BOOST_AUTO_TEST_CASE(test_range_erase_all);
BOOST_AUTO_TEST_CASE(test_range_erase);

BOOST_AUTO_TEST_CASE_TEMPLATE(
    test_erase_loop,
    HMap,
    test_types
    );

BOOST_AUTO_TEST_CASE_TEMPLATE(
    test_erase_loop_range,
    HMap,
    test_types
    );

BOOST_AUTO_TEST_CASE_TEMPLATE(
    test_insert_erase_insert,
    HMap,
    test_types
    );

BOOST_AUTO_TEST_CASE(test_range_erase_same_iterators);
BOOST_AUTO_TEST_CASE(test_max_load_factor_extreme_factors);
BOOST_AUTO_TEST_CASE(test_min_load_factor_extreme_factors);
BOOST_AUTO_TEST_CASE(test_min_load_factor);
BOOST_AUTO_TEST_CASE(test_min_load_factor_range_erase);
BOOST_AUTO_TEST_CASE(test_rehash_empty);
BOOST_AUTO_TEST_CASE(test_compare);
BOOST_AUTO_TEST_CASE(test_clear);
BOOST_AUTO_TEST_CASE(test_clear_with_min_load_factor);
BOOST_AUTO_TEST_CASE(test_modify_value_through_iterator);
BOOST_AUTO_TEST_CASE(test_modify_value_through_iterator_with_const_qualifier);
BOOST_AUTO_TEST_CASE(test_extreme_bucket_count_value_construction);
BOOST_AUTO_TEST_CASE(test_range_construct);
BOOST_AUTO_TEST_CASE(test_assign_operator);
BOOST_AUTO_TEST_CASE(test_move_constructor);
BOOST_AUTO_TEST_CASE(test_move_constructor_empty);
BOOST_AUTO_TEST_CASE(test_move_operator);
BOOST_AUTO_TEST_CASE(test_move_operator_empty);
BOOST_AUTO_TEST_CASE(test_reassign_moved_object_move_constructor);
BOOST_AUTO_TEST_CASE(test_reassign_moved_object_move_operator);
BOOST_AUTO_TEST_CASE(test_use_after_move_constructor);
BOOST_AUTO_TEST_CASE(test_use_after_move_operator);
BOOST_AUTO_TEST_CASE(test_copy_constructor_and_operator);
BOOST_AUTO_TEST_CASE(test_copy_constructor_empty);
BOOST_AUTO_TEST_CASE(test_copy_operator_empty);
BOOST_AUTO_TEST_CASE(test_at);
BOOST_AUTO_TEST_CASE(test_contains);
BOOST_AUTO_TEST_CASE(test_equal_range);
BOOST_AUTO_TEST_CASE(test_access_operator);
BOOST_AUTO_TEST_CASE(test_swap);
BOOST_AUTO_TEST_CASE(test_swap_empty);
BOOST_AUTO_TEST_CASE(test_serialize_desearialize_empty);
BOOST_AUTO_TEST_CASE(test_serialize_desearialize);
BOOST_AUTO_TEST_CASE(test_serialize_desearialize_with_store_hash);
BOOST_AUTO_TEST_CASE(test_serialize_desearialize_with_different_hash);
BOOST_AUTO_TEST_CASE(test_key_equal);
BOOST_AUTO_TEST_CASE(test_heterogeneous_lookups);
BOOST_AUTO_TEST_CASE(test_empty_map);
BOOST_AUTO_TEST_CASE(test_precalculated_hash);
BOOST_AUTO_TEST_CASE(test_erase_fast);

BOOST_AUTO_TEST_CASE_TEMPLATE(
    test_insert,
    HSet,
    test_types
    );

BOOST_AUTO_TEST_CASE(test_compare);
BOOST_AUTO_TEST_CASE(test_insert_pointer);
BOOST_AUTO_TEST_CASE(test_serialize_deserialize);
BOOST_AUTO_TEST_CASE(test_erase_fast);
std::int32_t utils::get_key< std::int32_t >(std::size_t counter);
std::int64_t utils::get_key< std::int64_t >(std::size_t counter);
std::string utils::get_key< std::string >(std::size_t counter);
std::int32_t utils::get_value< std::int32_t >(std::size_t counter);
std::int64_t utils::get_value< std::int64_t >(std::size_t counter);
std::string utils::get_value< std::string >(std::size_t counter);
void test_voxelmap_basic_ops();
void test_voxelmap_insert_2d_scan();

int main(
    ] int argc,
    ] char** argv
    );

int main(
    ] int argc,
    ] char** argv
    );

int main(
    ] int argc,
    ] char** argv
    );

int main(
    ] int argc,
    ] char** argv
    );

int main(
    ] int argc,
    ] char** argv
    );

TEST_CLASS_MOVE_COPY_CTORS(mola::SparseVoxelPointCloud);
TEST_CLASS_MOVE_COPY_CTORS(mola::OccGrid);
void test_serialization();

int main(
    ] int argc,
    ] char** argv
    );

void test_voxelmap_basic_ops();
void test_voxelmap_insert_2d_scan();

int main(
    ] int argc,
    ] char** argv
    );

int main(
    ] int argc,
    ] char** argv
    );

static void test1();

int main(
    ] int argc,
    ] char** argv
    );

int main(
    int argc,
    char** argv
    );

int main(
    int argc,
    char** argv
    );

int main(
    int argc,
    char** argv
    );

int main(
    int argc,
    char** argv
    );

int main(
    int argc,
    char** argv
    );

MRPT_INITIALIZER(do_register_MolaViz);
static ImGui_ImplAllegro5_Data* ImGui_ImplAllegro5_GetBackendData();
static void ImGui_ImplAllegro5_SetupRenderState(ImDrawData* draw_data);
void ImGui_ImplAllegro5_RenderDrawData(ImDrawData* draw_data);
bool ImGui_ImplAllegro5_CreateDeviceObjects();
void ImGui_ImplAllegro5_UpdateTexture(ImTextureData* tex);
void ImGui_ImplAllegro5_InvalidateDeviceObjects();
ImGuiKey ImGui_ImplAllegro5_KeyCodeToImGuiKey(int key_code);
bool ImGui_ImplAllegro5_Init(ALLEGRO_DISPLAY* display);
void ImGui_ImplAllegro5_Shutdown();
void ImGui_ImplAllegro5_SetDisplay(ALLEGRO_DISPLAY* display);
static void ImGui_ImplAllegro5_UpdateKeyModifiers();
bool ImGui_ImplAllegro5_ProcessEvent(ALLEGRO_EVENT* ev);
static void ImGui_ImplAllegro5_UpdateMouseCursor();
void ImGui_ImplAllegro5_NewFrame();
IMGUI_IMPL_API bool ImGui_ImplAllegro5_Init(ALLEGRO_DISPLAY* display);
IMGUI_IMPL_API void ImGui_ImplAllegro5_Shutdown();
IMGUI_IMPL_API void ImGui_ImplAllegro5_NewFrame();
IMGUI_IMPL_API void ImGui_ImplAllegro5_RenderDrawData(ImDrawData* draw_data);
IMGUI_IMPL_API bool ImGui_ImplAllegro5_ProcessEvent(ALLEGRO_EVENT* event);
IMGUI_IMPL_API void ImGui_ImplAllegro5_SetDisplay(ALLEGRO_DISPLAY* display);
IMGUI_IMPL_API bool ImGui_ImplAllegro5_CreateDeviceObjects();
IMGUI_IMPL_API void ImGui_ImplAllegro5_InvalidateDeviceObjects();
IMGUI_IMPL_API void ImGui_ImplAllegro5_UpdateTexture(ImTextureData* tex);
static ImGuiKey ImGui_ImplAndroid_KeyCodeToImGuiKey(int32_t key_code);
int32_t ImGui_ImplAndroid_HandleInputEvent(const AInputEvent* input_event);
bool ImGui_ImplAndroid_Init(ANativeWindow* window);
void ImGui_ImplAndroid_Shutdown();
void ImGui_ImplAndroid_NewFrame();
IMGUI_IMPL_API bool ImGui_ImplAndroid_Init(ANativeWindow* window);
IMGUI_IMPL_API int32_t ImGui_ImplAndroid_HandleInputEvent(const AInputEvent* input_event);
IMGUI_IMPL_API void ImGui_ImplAndroid_Shutdown();
IMGUI_IMPL_API void ImGui_ImplAndroid_NewFrame();
static ImGui_ImplDX10_Data* ImGui_ImplDX10_GetBackendData();
static void ImGui_ImplDX10_InitMultiViewportSupport();
static void ImGui_ImplDX10_ShutdownMultiViewportSupport();

static void ImGui_ImplDX10_SetupRenderState(
    ImDrawData* draw_data,
    ID3D10Device* device
    );

void ImGui_ImplDX10_RenderDrawData(ImDrawData* draw_data);
static void ImGui_ImplDX10_DestroyTexture(ImTextureData* tex);
void ImGui_ImplDX10_UpdateTexture(ImTextureData* tex);
bool ImGui_ImplDX10_CreateDeviceObjects();
void ImGui_ImplDX10_InvalidateDeviceObjects();
bool ImGui_ImplDX10_Init(ID3D10Device* device);
void ImGui_ImplDX10_Shutdown();
void ImGui_ImplDX10_NewFrame();
static void ImGui_ImplDX10_CreateWindow(ImGuiViewport* viewport);
static void ImGui_ImplDX10_DestroyWindow(ImGuiViewport* viewport);

static void ImGui_ImplDX10_SetWindowSize(
    ImGuiViewport* viewport,
    ImVec2 size
    );

static void ImGui_ImplDX10_RenderViewport(
    ImGuiViewport* viewport,
    void*
    );

static void ImGui_ImplDX10_SwapBuffers(
    ImGuiViewport* viewport,
    void*
    );

IMGUI_IMPL_API bool ImGui_ImplDX10_Init(ID3D10Device* device);
IMGUI_IMPL_API void ImGui_ImplDX10_Shutdown();
IMGUI_IMPL_API void ImGui_ImplDX10_NewFrame();
IMGUI_IMPL_API void ImGui_ImplDX10_RenderDrawData(ImDrawData* draw_data);
IMGUI_IMPL_API bool ImGui_ImplDX10_CreateDeviceObjects();
IMGUI_IMPL_API void ImGui_ImplDX10_InvalidateDeviceObjects();
IMGUI_IMPL_API void ImGui_ImplDX10_UpdateTexture(ImTextureData* tex);
static ImGui_ImplDX11_Data* ImGui_ImplDX11_GetBackendData();
static void ImGui_ImplDX11_InitMultiViewportSupport();
static void ImGui_ImplDX11_ShutdownMultiViewportSupport();

static void ImGui_ImplDX11_SetupRenderState(
    const ImDrawData* draw_data,
    ID3D11DeviceContext* device_ctx
    );

void ImGui_ImplDX11_RenderDrawData(ImDrawData* draw_data);
static void ImGui_ImplDX11_DestroyTexture(ImTextureData* tex);
void ImGui_ImplDX11_UpdateTexture(ImTextureData* tex);
bool ImGui_ImplDX11_CreateDeviceObjects();
void ImGui_ImplDX11_InvalidateDeviceObjects();

bool ImGui_ImplDX11_Init(
    ID3D11Device* device,
    ID3D11DeviceContext* device_context
    );

void ImGui_ImplDX11_Shutdown();
void ImGui_ImplDX11_NewFrame();

void ImGui_ImplDX11_SetSwapChainDescs(
    const DXGI_SWAP_CHAIN_DESC* desc_templates,
    int desc_templates_count
    );

static void ImGui_ImplDX11_CreateWindow(ImGuiViewport* viewport);
static void ImGui_ImplDX11_DestroyWindow(ImGuiViewport* viewport);

static void ImGui_ImplDX11_SetWindowSize(
    ImGuiViewport* viewport,
    ImVec2 size
    );

static void ImGui_ImplDX11_RenderWindow(
    ImGuiViewport* viewport,
    void*
    );

static void ImGui_ImplDX11_SwapBuffers(
    ImGuiViewport* viewport,
    void*
    );

IMGUI_IMPL_API bool ImGui_ImplDX11_Init(
    ID3D11Device* device,
    ID3D11DeviceContext* device_context
    );

IMGUI_IMPL_API void ImGui_ImplDX11_Shutdown();
IMGUI_IMPL_API void ImGui_ImplDX11_NewFrame();
IMGUI_IMPL_API void ImGui_ImplDX11_RenderDrawData(ImDrawData* draw_data);
IMGUI_IMPL_API bool ImGui_ImplDX11_CreateDeviceObjects();
IMGUI_IMPL_API void ImGui_ImplDX11_InvalidateDeviceObjects();
IMGUI_IMPL_API void ImGui_ImplDX11_UpdateTexture(ImTextureData* tex);
static ImGui_ImplDX12_Data* ImGui_ImplDX12_GetBackendData();
static void ImGui_ImplDX12_InitMultiViewportSupport();
static void ImGui_ImplDX12_ShutdownMultiViewportSupport();
void ImGui_ImplDX12_SetupSamplerLinear(ID3D12GraphicsCommandList* command_list);
void ImGui_ImplDX12_SetupSamplerNearest(ID3D12GraphicsCommandList* command_list);

static void ImGui_ImplDX12_SetupRenderState(
    ImDrawData* draw_data,
    ID3D12GraphicsCommandList* command_list,
    ImGui_ImplDX12_RenderBuffers* fr
    );

template <typename T>
static void SafeRelease(T*& res);

void ImGui_ImplDX12_RenderDrawData(
    ImDrawData* draw_data,
    ID3D12GraphicsCommandList* command_list
    );

static void ImGui_ImplDX12_DestroyTexture(ImTextureData* tex);
void ImGui_ImplDX12_UpdateTexture(ImTextureData* tex);
bool ImGui_ImplDX12_CreateDeviceObjects();
static void ImGui_ImplDX12_DestroyRenderBuffers(ImGui_ImplDX12_RenderBuffers* render_buffers);
void ImGui_ImplDX12_InvalidateDeviceObjects();
static void ImGui_ImplDX12_InitLegacySingleDescriptorMode(ImGui_ImplDX12_InitInfo* init_info);
bool ImGui_ImplDX12_Init(ImGui_ImplDX12_InitInfo* init_info);

bool ImGui_ImplDX12_Init(
    ID3D12Device* device,
    int num_frames_in_flight,
    DXGI_FORMAT rtv_format,
    ID3D12DescriptorHeap* srv_descriptor_heap,
    D3D12_CPU_DESCRIPTOR_HANDLE font_srv_cpu_desc_handle,
    D3D12_GPU_DESCRIPTOR_HANDLE font_srv_gpu_desc_handle
    );

void ImGui_ImplDX12_Shutdown();
void ImGui_ImplDX12_NewFrame();
static void ImGui_ImplDX12_CreateWindow(ImGuiViewport* viewport);
static void ImGui_WaitForPendingOperations(ImGui_ImplDX12_ViewportData* vd);
static ImGui_ImplDX12_FrameContext* ImGui_WaitForNextFrameContext(ImGui_ImplDX12_ViewportData* vd);
static void ImGui_ImplDX12_DestroyWindow(ImGuiViewport* viewport);

static void ImGui_ImplDX12_SetWindowSize(
    ImGuiViewport* viewport,
    ImVec2 size
    );

static void ImGui_ImplDX12_RenderWindow(
    ImGuiViewport* viewport,
    void*
    );

static void ImGui_ImplDX12_SwapBuffers(
    ImGuiViewport* viewport,
    void*
    );

IMGUI_IMPL_API bool ImGui_ImplDX12_Init(ImGui_ImplDX12_InitInfo* info);
IMGUI_IMPL_API void ImGui_ImplDX12_Shutdown();
IMGUI_IMPL_API void ImGui_ImplDX12_NewFrame();

IMGUI_IMPL_API void ImGui_ImplDX12_RenderDrawData(
    ImDrawData* draw_data,
    ID3D12GraphicsCommandList* graphics_command_list
    );

IMGUI_IMPL_API bool ImGui_ImplDX12_Init(
    ID3D12Device* device,
    int num_frames_in_flight,
    DXGI_FORMAT rtv_format,
    ID3D12DescriptorHeap* srv_descriptor_heap,
    D3D12_CPU_DESCRIPTOR_HANDLE font_srv_cpu_desc_handle,
    D3D12_GPU_DESCRIPTOR_HANDLE font_srv_gpu_desc_handle
    );

IMGUI_IMPL_API bool ImGui_ImplDX12_CreateDeviceObjects();
IMGUI_IMPL_API void ImGui_ImplDX12_InvalidateDeviceObjects();
IMGUI_IMPL_API void ImGui_ImplDX12_UpdateTexture(ImTextureData* tex);
static ImGui_ImplDX9_Data* ImGui_ImplDX9_GetBackendData();
static void ImGui_ImplDX9_InitMultiViewportSupport();
static void ImGui_ImplDX9_ShutdownMultiViewportSupport();
static void ImGui_ImplDX9_CreateDeviceObjectsForPlatformWindows();
static void ImGui_ImplDX9_InvalidateDeviceObjectsForPlatformWindows();
static void ImGui_ImplDX9_SetupRenderState(ImDrawData* draw_data);
void ImGui_ImplDX9_RenderDrawData(ImDrawData* draw_data);

static bool ImGui_ImplDX9_CheckFormatSupport(
    LPDIRECT3DDEVICE9 pDevice,
    D3DFORMAT format
    );

bool ImGui_ImplDX9_Init(IDirect3DDevice9* device);
void ImGui_ImplDX9_Shutdown();

static void ImGui_ImplDX9_CopyTextureRegion(
    bool tex_use_colors,
    const ImU32* src,
    int src_pitch,
    ImU32* dst,
    int dst_pitch,
    int w,
    int h
    );

void ImGui_ImplDX9_UpdateTexture(ImTextureData* tex);
bool ImGui_ImplDX9_CreateDeviceObjects();
void ImGui_ImplDX9_InvalidateDeviceObjects();
void ImGui_ImplDX9_NewFrame();
static void ImGui_ImplDX9_CreateWindow(ImGuiViewport* viewport);
static void ImGui_ImplDX9_DestroyWindow(ImGuiViewport* viewport);

static void ImGui_ImplDX9_SetWindowSize(
    ImGuiViewport* viewport,
    ImVec2 size
    );

static void ImGui_ImplDX9_RenderWindow(
    ImGuiViewport* viewport,
    void*
    );

static void ImGui_ImplDX9_SwapBuffers(
    ImGuiViewport* viewport,
    void*
    );

IMGUI_IMPL_API bool ImGui_ImplDX9_Init(IDirect3DDevice9* device);
IMGUI_IMPL_API void ImGui_ImplDX9_Shutdown();
IMGUI_IMPL_API void ImGui_ImplDX9_NewFrame();
IMGUI_IMPL_API void ImGui_ImplDX9_RenderDrawData(ImDrawData* draw_data);
IMGUI_IMPL_API bool ImGui_ImplDX9_CreateDeviceObjects();
IMGUI_IMPL_API void ImGui_ImplDX9_InvalidateDeviceObjects();
IMGUI_IMPL_API void ImGui_ImplDX9_UpdateTexture(ImTextureData* tex);

static void ImGui_ImplGlfw_ContextMap_Add(
    GLFWwindow* window,
    ImGuiContext* ctx
    );

static void ImGui_ImplGlfw_ContextMap_Remove(GLFWwindow* window);
static ImGuiContext* ImGui_ImplGlfw_ContextMap_Get(GLFWwindow* window);
static ImGui_ImplGlfw_Data* ImGui_ImplGlfw_GetBackendData();
static ImGui_ImplGlfw_Data* ImGui_ImplGlfw_GetBackendData(GLFWwindow* window);
static void ImGui_ImplGlfw_UpdateMonitors();
static void ImGui_ImplGlfw_InitMultiViewportSupport();
static void ImGui_ImplGlfw_ShutdownMultiViewportSupport();
static bool ImGui_ImplGlfw_IsWayland();

ImGuiKey ImGui_ImplGlfw_KeyToImGuiKey(
    int keycode,
    int scancode
    );

static void ImGui_ImplGlfw_UpdateKeyModifiers(
    ImGuiIO& io,
    GLFWwindow* window
    );

static bool ImGui_ImplGlfw_ShouldChainCallback(
    ImGui_ImplGlfw_Data* bd,
    GLFWwindow* window
    );

void ImGui_ImplGlfw_MouseButtonCallback(
    GLFWwindow* window,
    int button,
    int action,
    int mods
    );

void ImGui_ImplGlfw_ScrollCallback(
    GLFWwindow* window,
    double xoffset,
    double yoffset
    );

static int ImGui_ImplGlfw_TranslateUntranslatedKey(
    int key,
    int scancode
    );

void ImGui_ImplGlfw_KeyCallback(
    GLFWwindow* window,
    int keycode,
    int scancode,
    int action,
    int mods
    );

void ImGui_ImplGlfw_WindowFocusCallback(
    GLFWwindow* window,
    int focused
    );

void ImGui_ImplGlfw_CursorPosCallback(
    GLFWwindow* window,
    double x,
    double y
    );

void ImGui_ImplGlfw_CursorEnterCallback(
    GLFWwindow* window,
    int entered
    );

void ImGui_ImplGlfw_CharCallback(
    GLFWwindow* window,
    unsigned int c
    );

void ImGui_ImplGlfw_MonitorCallback(
    GLFWmonitor* monitor,
    int event
    );

void ImGui_ImplGlfw_InstallCallbacks(GLFWwindow* window);
void ImGui_ImplGlfw_RestoreCallbacks(GLFWwindow* window);
void ImGui_ImplGlfw_SetCallbacksChainForAllWindows(bool chain_for_all_windows);

static bool ImGui_ImplGlfw_Init(
    GLFWwindow* window,
    bool install_callbacks,
    GlfwClientApi client_api
    );

bool ImGui_ImplGlfw_InitForOpenGL(
    GLFWwindow* window,
    bool install_callbacks
    );

bool ImGui_ImplGlfw_InitForVulkan(
    GLFWwindow* window,
    bool install_callbacks
    );

bool ImGui_ImplGlfw_InitForOther(
    GLFWwindow* window,
    bool install_callbacks
    );

void ImGui_ImplGlfw_Shutdown();
static void ImGui_ImplGlfw_UpdateMouseData();
static void ImGui_ImplGlfw_UpdateMouseCursor();
static float Saturate(float v);
static void ImGui_ImplGlfw_UpdateGamepads();
float ImGui_ImplGlfw_GetContentScaleForWindow(GLFWwindow* window);
float ImGui_ImplGlfw_GetContentScaleForMonitor(GLFWmonitor* monitor);

static void ImGui_ImplGlfw_GetWindowSizeAndFramebufferScale(
    GLFWwindow* window,
    ImVec2* out_size,
    ImVec2* out_framebuffer_scale
    );

void ImGui_ImplGlfw_NewFrame();
void ImGui_ImplGlfw_Sleep(int milliseconds);
static void ImGui_ImplGlfw_WindowCloseCallback(GLFWwindow* window);

static void ImGui_ImplGlfw_WindowPosCallback(
    GLFWwindow* window,
    int,
    int
    );

static void ImGui_ImplGlfw_WindowSizeCallback(
    GLFWwindow* window,
    int,
    int
    );

static void ImGui_ImplGlfw_CreateWindow(ImGuiViewport* viewport);
static void ImGui_ImplGlfw_DestroyWindow(ImGuiViewport* viewport);
static void ImGui_ImplGlfw_ShowWindow(ImGuiViewport* viewport);
static ImVec2 ImGui_ImplGlfw_GetWindowPos(ImGuiViewport* viewport);

static void ImGui_ImplGlfw_SetWindowPos(
    ImGuiViewport* viewport,
    ImVec2 pos
    );

static ImVec2 ImGui_ImplGlfw_GetWindowSize(ImGuiViewport* viewport);

static void ImGui_ImplGlfw_SetWindowSize(
    ImGuiViewport* viewport,
    ImVec2 size
    );

static ImVec2 ImGui_ImplGlfw_GetWindowFramebufferScale(ImGuiViewport* viewport);

static void ImGui_ImplGlfw_SetWindowTitle(
    ImGuiViewport* viewport,
    const char* title
    );

static void ImGui_ImplGlfw_SetWindowFocus(ImGuiViewport* viewport);
static bool ImGui_ImplGlfw_GetWindowFocus(ImGuiViewport* viewport);
static bool ImGui_ImplGlfw_GetWindowMinimized(ImGuiViewport* viewport);

static void ImGui_ImplGlfw_RenderWindow(
    ImGuiViewport* viewport,
    void*
    );

static void ImGui_ImplGlfw_SwapBuffers(
    ImGuiViewport* viewport,
    void*
    );

IMGUI_IMPL_API bool ImGui_ImplGlfw_InitForOpenGL(
    GLFWwindow* window,
    bool install_callbacks
    );

IMGUI_IMPL_API bool ImGui_ImplGlfw_InitForVulkan(
    GLFWwindow* window,
    bool install_callbacks
    );

IMGUI_IMPL_API bool ImGui_ImplGlfw_InitForOther(
    GLFWwindow* window,
    bool install_callbacks
    );

IMGUI_IMPL_API void ImGui_ImplGlfw_Shutdown();
IMGUI_IMPL_API void ImGui_ImplGlfw_NewFrame();
IMGUI_IMPL_API void ImGui_ImplGlfw_InstallCallbacks(GLFWwindow* window);
IMGUI_IMPL_API void ImGui_ImplGlfw_RestoreCallbacks(GLFWwindow* window);
IMGUI_IMPL_API void ImGui_ImplGlfw_SetCallbacksChainForAllWindows(bool chain_for_all_windows);

IMGUI_IMPL_API void ImGui_ImplGlfw_WindowFocusCallback(
    GLFWwindow* window,
    int focused
    );

IMGUI_IMPL_API void ImGui_ImplGlfw_CursorEnterCallback(
    GLFWwindow* window,
    int entered
    );

IMGUI_IMPL_API void ImGui_ImplGlfw_CursorPosCallback(
    GLFWwindow* window,
    double x,
    double y
    );

IMGUI_IMPL_API void ImGui_ImplGlfw_MouseButtonCallback(
    GLFWwindow* window,
    int button,
    int action,
    int mods
    );

IMGUI_IMPL_API void ImGui_ImplGlfw_ScrollCallback(
    GLFWwindow* window,
    double xoffset,
    double yoffset
    );

IMGUI_IMPL_API void ImGui_ImplGlfw_KeyCallback(
    GLFWwindow* window,
    int key,
    int scancode,
    int action,
    int mods
    );

IMGUI_IMPL_API void ImGui_ImplGlfw_CharCallback(
    GLFWwindow* window,
    unsigned int c
    );

IMGUI_IMPL_API void ImGui_ImplGlfw_MonitorCallback(
    GLFWmonitor* monitor,
    int event
    );

IMGUI_IMPL_API void ImGui_ImplGlfw_Sleep(int milliseconds);
IMGUI_IMPL_API float ImGui_ImplGlfw_GetContentScaleForWindow(GLFWwindow* window);
IMGUI_IMPL_API float ImGui_ImplGlfw_GetContentScaleForMonitor(GLFWmonitor* monitor);
static ImGuiKey ImGui_ImplGLUT_KeyToImGuiKey(int key);
bool ImGui_ImplGLUT_Init();
void ImGui_ImplGLUT_InstallFuncs();
void ImGui_ImplGLUT_Shutdown();
void ImGui_ImplGLUT_NewFrame();
static void ImGui_ImplGLUT_UpdateKeyModifiers();

static void ImGui_ImplGLUT_AddKeyEvent(
    ImGuiKey key,
    bool down,
    int native_keycode
    );

void ImGui_ImplGLUT_KeyboardFunc(
    unsigned char c,
    int x,
    int y
    );

void ImGui_ImplGLUT_KeyboardUpFunc(
    unsigned char c,
    int x,
    int y
    );

void ImGui_ImplGLUT_SpecialFunc(
    int key,
    int x,
    int y
    );

void ImGui_ImplGLUT_SpecialUpFunc(
    int key,
    int x,
    int y
    );

void ImGui_ImplGLUT_MouseFunc(
    int glut_button,
    int state,
    int x,
    int y
    );

void ImGui_ImplGLUT_ReshapeFunc(
    int w,
    int h
    );

void ImGui_ImplGLUT_MotionFunc(
    int x,
    int y
    );

IMGUI_IMPL_API bool ImGui_ImplGLUT_Init();
IMGUI_IMPL_API void ImGui_ImplGLUT_InstallFuncs();
IMGUI_IMPL_API void ImGui_ImplGLUT_Shutdown();
IMGUI_IMPL_API void ImGui_ImplGLUT_NewFrame();

IMGUI_IMPL_API void ImGui_ImplGLUT_ReshapeFunc(
    int w,
    int h
    );

IMGUI_IMPL_API void ImGui_ImplGLUT_MotionFunc(
    int x,
    int y
    );

IMGUI_IMPL_API void ImGui_ImplGLUT_MouseFunc(
    int button,
    int state,
    int x,
    int y
    );

IMGUI_IMPL_API void ImGui_ImplGLUT_MouseWheelFunc(
    int button,
    int dir,
    int x,
    int y
    );

IMGUI_IMPL_API void ImGui_ImplGLUT_KeyboardFunc(
    unsigned char c,
    int x,
    int y
    );

IMGUI_IMPL_API void ImGui_ImplGLUT_KeyboardUpFunc(
    unsigned char c,
    int x,
    int y
    );

IMGUI_IMPL_API void ImGui_ImplGLUT_SpecialFunc(
    int key,
    int x,
    int y
    );

IMGUI_IMPL_API void ImGui_ImplGLUT_SpecialUpFunc(
    int key,
    int x,
    int y
    );

IMGUI_IMPL_API bool ImGui_ImplNull_Init();
IMGUI_IMPL_API void ImGui_ImplNull_Shutdown();
IMGUI_IMPL_API void ImGui_ImplNull_NewFrame();
IMGUI_IMPL_API bool ImGui_ImplNullPlatform_Init();
IMGUI_IMPL_API void ImGui_ImplNullPlatform_Shutdown();
IMGUI_IMPL_API void ImGui_ImplNullPlatform_NewFrame();
IMGUI_IMPL_API bool ImGui_ImplNullRender_Init();
IMGUI_IMPL_API void ImGui_ImplNullRender_Shutdown();
IMGUI_IMPL_API void ImGui_ImplNullRender_NewFrame();
static void ImGui_ImplNullRender_UpdateTexture(ImTextureData* tex);
IMGUI_IMPL_API void ImGui_ImplNullRender_RenderDrawData(ImDrawData* draw_data);
IMGUI_IMPL_API bool ImGui_ImplNull_Init();
IMGUI_IMPL_API void ImGui_ImplNull_Shutdown();
IMGUI_IMPL_API void ImGui_ImplNull_NewFrame();
IMGUI_IMPL_API bool ImGui_ImplNullPlatform_Init();
IMGUI_IMPL_API void ImGui_ImplNullPlatform_Shutdown();
IMGUI_IMPL_API void ImGui_ImplNullPlatform_NewFrame();
IMGUI_IMPL_API bool ImGui_ImplNullRender_Init();
IMGUI_IMPL_API void ImGui_ImplNullRender_Shutdown();
IMGUI_IMPL_API void ImGui_ImplNullRender_NewFrame();
IMGUI_IMPL_API void ImGui_ImplNullRender_RenderDrawData(ImDrawData* draw_data);
static ImGui_ImplOpenGL2_Data* ImGui_ImplOpenGL2_GetBackendData();
static void ImGui_ImplOpenGL2_InitMultiViewportSupport();
static void ImGui_ImplOpenGL2_ShutdownMultiViewportSupport();
bool ImGui_ImplOpenGL2_Init();
void ImGui_ImplOpenGL2_Shutdown();
void ImGui_ImplOpenGL2_NewFrame();

static void ImGui_ImplOpenGL2_SetupRenderState(
    ImDrawData* draw_data,
    int fb_width,
    int fb_height
    );

void ImGui_ImplOpenGL2_RenderDrawData(ImDrawData* draw_data);
void ImGui_ImplOpenGL2_UpdateTexture(ImTextureData* tex);
bool ImGui_ImplOpenGL2_CreateDeviceObjects();
void ImGui_ImplOpenGL2_DestroyDeviceObjects();

static void ImGui_ImplOpenGL2_RenderWindow(
    ImGuiViewport* viewport,
    void*
    );

IMGUI_IMPL_API bool ImGui_ImplOpenGL2_Init();
IMGUI_IMPL_API void ImGui_ImplOpenGL2_Shutdown();
IMGUI_IMPL_API void ImGui_ImplOpenGL2_NewFrame();
IMGUI_IMPL_API void ImGui_ImplOpenGL2_RenderDrawData(ImDrawData* draw_data);
IMGUI_IMPL_API bool ImGui_ImplOpenGL2_CreateDeviceObjects();
IMGUI_IMPL_API void ImGui_ImplOpenGL2_DestroyDeviceObjects();
IMGUI_IMPL_API void ImGui_ImplOpenGL2_UpdateTexture(ImTextureData* tex);
static ImGui_ImplOpenGL3_Data* ImGui_ImplOpenGL3_GetBackendData();
static void ImGui_ImplOpenGL3_InitMultiViewportSupport();
static void ImGui_ImplOpenGL3_ShutdownMultiViewportSupport();
bool ImGui_ImplOpenGL3_InitLoader();
static void ImGui_ImplOpenGL3_ShutdownLoader();
bool ImGui_ImplOpenGL3_Init(const char* glsl_version);
void ImGui_ImplOpenGL3_Shutdown();
void ImGui_ImplOpenGL3_NewFrame();

static void ImGui_ImplOpenGL3_SetupRenderState(
    ImDrawData* draw_data,
    int fb_width,
    int fb_height,
    GLuint vertex_array_object
    );

void ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data);
static void ImGui_ImplOpenGL3_DestroyTexture(ImTextureData* tex);
void ImGui_ImplOpenGL3_UpdateTexture(ImTextureData* tex);

static bool CheckShader(
    GLuint handle,
    const char* desc
    );

static bool CheckProgram(
    GLuint handle,
    const char* desc
    );

bool ImGui_ImplOpenGL3_CreateDeviceObjects();
void ImGui_ImplOpenGL3_DestroyDeviceObjects();

static void ImGui_ImplOpenGL3_RenderWindow(
    ImGuiViewport* viewport,
    void*
    );

IMGUI_IMPL_API bool ImGui_ImplOpenGL3_Init(const char* glsl_version = nullptr);
IMGUI_IMPL_API void ImGui_ImplOpenGL3_Shutdown();
IMGUI_IMPL_API void ImGui_ImplOpenGL3_NewFrame();
IMGUI_IMPL_API void ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data);
IMGUI_IMPL_API bool ImGui_ImplOpenGL3_CreateDeviceObjects();
IMGUI_IMPL_API void ImGui_ImplOpenGL3_DestroyDeviceObjects();
IMGUI_IMPL_API void ImGui_ImplOpenGL3_UpdateTexture(ImTextureData* tex);
typedef void(APIENTRYP PFNGLPOLYGONMODEPROC);
typedef GLenum(APIENTRYP PFNGLGETERRORPROC);
typedef GLboolean(APIENTRYP PFNGLISENABLEDPROC);
typedef GLuint(APIENTRYP PFNGLCREATEPROGRAMPROC);
typedef GLint(APIENTRYP PFNGLGETATTRIBLOCATIONPROC);
GL3W_API int imgl3wInit(void);
GL3W_API int imgl3wInit2(GL3WGetProcAddressProc proc);
GL3W_API void imgl3wShutdown(void);

GL3W_API int imgl3wIsSupported(
    int major,
    int minor
    );

GL3W_API GL3WglProc imgl3wGetProcAddress(const char* proc);
static ImGui_ImplSDL2_Data* ImGui_ImplSDL2_GetBackendData();
static void ImGui_ImplSDL2_UpdateMonitors();

static void ImGui_ImplSDL2_InitMultiViewportSupport(
    SDL_Window* window,
    void* sdl_gl_context
    );

static void ImGui_ImplSDL2_ShutdownMultiViewportSupport();
static const char* ImGui_ImplSDL2_GetClipboardText(ImGuiContext*);

static void ImGui_ImplSDL2_SetClipboardText(
    ImGuiContext*,
    const char* text
    );

static void ImGui_ImplSDL2_PlatformSetImeData(
    ImGuiContext*,
    ImGuiViewport* viewport,
    ImGuiPlatformImeData* data
    );

ImGuiKey ImGui_ImplSDL2_KeyEventToImGuiKey(
    SDL_Keycode keycode,
    SDL_Scancode scancode
    );

static void ImGui_ImplSDL2_UpdateKeyModifiers(SDL_Keymod sdl_key_mods);
static ImGuiViewport* ImGui_ImplSDL2_GetViewportForWindowID(Uint32 window_id);
bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event);

static bool ImGui_ImplSDL2_Init(
    SDL_Window* window,
    SDL_Renderer* renderer,
    void* sdl_gl_context
    );

bool ImGui_ImplSDL2_InitForOpenGL(
    SDL_Window* window,
    void* sdl_gl_context
    );

bool ImGui_ImplSDL2_InitForVulkan(SDL_Window* window);
bool ImGui_ImplSDL2_InitForD3D(SDL_Window* window);
bool ImGui_ImplSDL2_InitForMetal(SDL_Window* window);

bool ImGui_ImplSDL2_InitForSDLRenderer(
    SDL_Window* window,
    SDL_Renderer* renderer
    );

bool ImGui_ImplSDL2_InitForOther(SDL_Window* window);
static void ImGui_ImplSDL2_CloseGamepads();
void ImGui_ImplSDL2_Shutdown();
void ImGui_ImplSDL2_SetMouseCaptureMode(ImGui_ImplSDL2_MouseCaptureMode mode);
static void ImGui_ImplSDL2_UpdateMouseData();
static void ImGui_ImplSDL2_UpdateMouseCursor();
float ImGui_ImplSDL2_GetContentScaleForWindow(SDL_Window* window);
float ImGui_ImplSDL2_GetContentScaleForDisplay(int display_index);

void ImGui_ImplSDL2_SetGamepadMode(
    ImGui_ImplSDL2_GamepadMode mode,
    struct _SDL_GameController** manual_gamepads_array,
    int manual_gamepads_count
    );

static void ImGui_ImplSDL2_UpdateGamepadButton(
    ImGui_ImplSDL2_Data* bd,
    ImGuiIO& io,
    ImGuiKey key,
    SDL_GameControllerButton button_no
    );

static float Saturate(float v);

static void ImGui_ImplSDL2_UpdateGamepadAnalog(
    ImGui_ImplSDL2_Data* bd,
    ImGuiIO& io,
    ImGuiKey key,
    SDL_GameControllerAxis axis_no,
    float v0,
    float v1
    );

static void ImGui_ImplSDL2_UpdateGamepads();

static void ImGui_ImplSDL2_GetWindowSizeAndFramebufferScale(
    SDL_Window* window,
    SDL_Renderer* renderer,
    ImVec2* out_size,
    ImVec2* out_framebuffer_scale
    );

void ImGui_ImplSDL2_NewFrame();
static void ImGui_ImplSDL2_CreateWindow(ImGuiViewport* viewport);
static void ImGui_ImplSDL2_DestroyWindow(ImGuiViewport* viewport);
static void ImGui_ImplSDL2_ShowWindow(ImGuiViewport* viewport);
static ImVec2 ImGui_ImplSDL2_GetWindowPos(ImGuiViewport* viewport);

static void ImGui_ImplSDL2_SetWindowPos(
    ImGuiViewport* viewport,
    ImVec2 pos
    );

static ImVec2 ImGui_ImplSDL2_GetWindowSize(ImGuiViewport* viewport);

static void ImGui_ImplSDL2_SetWindowSize(
    ImGuiViewport* viewport,
    ImVec2 size
    );

static ImVec2 ImGui_ImplSDL2_GetWindowFramebufferScale(ImGuiViewport* viewport);

static void ImGui_ImplSDL2_SetWindowTitle(
    ImGuiViewport* viewport,
    const char* title
    );

static void ImGui_ImplSDL2_SetWindowFocus(ImGuiViewport* viewport);
static bool ImGui_ImplSDL2_GetWindowFocus(ImGuiViewport* viewport);
static bool ImGui_ImplSDL2_GetWindowMinimized(ImGuiViewport* viewport);

static void ImGui_ImplSDL2_RenderWindow(
    ImGuiViewport* viewport,
    void*
    );

static void ImGui_ImplSDL2_SwapBuffers(
    ImGuiViewport* viewport,
    void*
    );

IMGUI_IMPL_API bool ImGui_ImplSDL2_InitForOpenGL(
    SDL_Window* window,
    void* sdl_gl_context
    );

IMGUI_IMPL_API bool ImGui_ImplSDL2_InitForVulkan(SDL_Window* window);
IMGUI_IMPL_API bool ImGui_ImplSDL2_InitForD3D(SDL_Window* window);
IMGUI_IMPL_API bool ImGui_ImplSDL2_InitForMetal(SDL_Window* window);

IMGUI_IMPL_API bool ImGui_ImplSDL2_InitForSDLRenderer(
    SDL_Window* window,
    SDL_Renderer* renderer
    );

IMGUI_IMPL_API bool ImGui_ImplSDL2_InitForOther(SDL_Window* window);
IMGUI_IMPL_API void ImGui_ImplSDL2_Shutdown();
IMGUI_IMPL_API void ImGui_ImplSDL2_NewFrame();
IMGUI_IMPL_API bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event);
IMGUI_IMPL_API float ImGui_ImplSDL2_GetContentScaleForWindow(SDL_Window* window);
IMGUI_IMPL_API float ImGui_ImplSDL2_GetContentScaleForDisplay(int display_index);

IMGUI_IMPL_API void ImGui_ImplSDL2_SetGamepadMode(
    ImGui_ImplSDL2_GamepadMode mode,
    struct _SDL_GameController** manual_gamepads_array = nullptr,
    int manual_gamepads_count = -1
    );

IMGUI_IMPL_API void ImGui_ImplSDL2_SetMouseCaptureMode(ImGui_ImplSDL2_MouseCaptureMode mode);
static ImGui_ImplSDL3_Data* ImGui_ImplSDL3_GetBackendData();
static void ImGui_ImplSDL3_UpdateIme();
static void ImGui_ImplSDL3_UpdateMonitors();

static void ImGui_ImplSDL3_InitMultiViewportSupport(
    SDL_Window* window,
    void* sdl_gl_context
    );

static void ImGui_ImplSDL3_ShutdownMultiViewportSupport();
static const char* ImGui_ImplSDL3_GetClipboardText(ImGuiContext*);

static void ImGui_ImplSDL3_SetClipboardText(
    ImGuiContext*,
    const char* text
    );

static ImGuiViewport* ImGui_ImplSDL3_GetViewportForWindowID(SDL_WindowID window_id);

static void ImGui_ImplSDL3_PlatformSetImeData(
    ImGuiContext*,
    ImGuiViewport*,
    ImGuiPlatformImeData* data
    );

ImGuiKey ImGui_ImplSDL3_KeyEventToImGuiKey(
    SDL_Keycode keycode,
    SDL_Scancode scancode
    );

static void ImGui_ImplSDL3_UpdateKeyModifiers(SDL_Keymod sdl_key_mods);
bool ImGui_ImplSDL3_ProcessEvent(const SDL_Event* event);

static void ImGui_ImplSDL3_SetupPlatformHandles(
    ImGuiViewport* viewport,
    SDL_Window* window
    );

static bool ImGui_ImplSDL3_Init(
    SDL_Window* window,
    SDL_Renderer* renderer,
    void* sdl_gl_context
    );

bool ImGui_ImplSDL3_InitForOpenGL(
    SDL_Window* window,
    void* sdl_gl_context
    );

bool ImGui_ImplSDL3_InitForVulkan(SDL_Window* window);
bool ImGui_ImplSDL3_InitForD3D(SDL_Window* window);
bool ImGui_ImplSDL3_InitForMetal(SDL_Window* window);

bool ImGui_ImplSDL3_InitForSDLRenderer(
    SDL_Window* window,
    SDL_Renderer* renderer
    );

bool ImGui_ImplSDL3_InitForSDLGPU(SDL_Window* window);
bool ImGui_ImplSDL3_InitForOther(SDL_Window* window);
static void ImGui_ImplSDL3_CloseGamepads();
void ImGui_ImplSDL3_Shutdown();
void ImGui_ImplSDL3_SetMouseCaptureMode(ImGui_ImplSDL3_MouseCaptureMode mode);
static void ImGui_ImplSDL3_UpdateMouseData();
static void ImGui_ImplSDL3_UpdateMouseCursor();

void ImGui_ImplSDL3_SetGamepadMode(
    ImGui_ImplSDL3_GamepadMode mode,
    SDL_Gamepad** manual_gamepads_array,
    int manual_gamepads_count
    );

static void ImGui_ImplSDL3_UpdateGamepadButton(
    ImGui_ImplSDL3_Data* bd,
    ImGuiIO& io,
    ImGuiKey key,
    SDL_GamepadButton button_no
    );

static float Saturate(float v);

static void ImGui_ImplSDL3_UpdateGamepadAnalog(
    ImGui_ImplSDL3_Data* bd,
    ImGuiIO& io,
    ImGuiKey key,
    SDL_GamepadAxis axis_no,
    float v0,
    float v1
    );

static void ImGui_ImplSDL3_UpdateGamepads();

static void ImGui_ImplSDL3_GetWindowSizeAndFramebufferScale(
    SDL_Window* window,
    ImVec2* out_size,
    ImVec2* out_framebuffer_scale
    );

void ImGui_ImplSDL3_NewFrame();
static SDL_Window* ImGui_ImplSDL3_GetSDLWindowFromViewport(ImGuiViewport* viewport);
static void ImGui_ImplSDL3_CreateWindow(ImGuiViewport* viewport);
static void ImGui_ImplSDL3_DestroyWindow(ImGuiViewport* viewport);
static void ImGui_ImplSDL3_ShowWindow(ImGuiViewport* viewport);
static void ImGui_ImplSDL3_UpdateWindow(ImGuiViewport* viewport);
static ImVec2 ImGui_ImplSDL3_GetWindowPos(ImGuiViewport* viewport);

static void ImGui_ImplSDL3_SetWindowPos(
    ImGuiViewport* viewport,
    ImVec2 pos
    );

static ImVec2 ImGui_ImplSDL3_GetWindowSize(ImGuiViewport* viewport);

static void ImGui_ImplSDL3_SetWindowSize(
    ImGuiViewport* viewport,
    ImVec2 size
    );

static ImVec2 ImGui_ImplSDL3_GetWindowFramebufferScale(ImGuiViewport* viewport);

static void ImGui_ImplSDL3_SetWindowTitle(
    ImGuiViewport* viewport,
    const char* title
    );

static void ImGui_ImplSDL3_SetWindowAlpha(
    ImGuiViewport* viewport,
    float alpha
    );

static void ImGui_ImplSDL3_SetWindowFocus(ImGuiViewport* viewport);
static bool ImGui_ImplSDL3_GetWindowFocus(ImGuiViewport* viewport);
static bool ImGui_ImplSDL3_GetWindowMinimized(ImGuiViewport* viewport);

static void ImGui_ImplSDL3_RenderWindow(
    ImGuiViewport* viewport,
    void*
    );

static void ImGui_ImplSDL3_SwapBuffers(
    ImGuiViewport* viewport,
    void*
    );

static int ImGui_ImplSDL3_CreateVkSurface(
    ImGuiViewport* viewport,
    ImU64 vk_instance,
    const void* vk_allocator,
    ImU64* out_vk_surface
    );

IMGUI_IMPL_API bool ImGui_ImplSDL3_InitForOpenGL(
    SDL_Window* window,
    void* sdl_gl_context
    );

IMGUI_IMPL_API bool ImGui_ImplSDL3_InitForVulkan(SDL_Window* window);
IMGUI_IMPL_API bool ImGui_ImplSDL3_InitForD3D(SDL_Window* window);
IMGUI_IMPL_API bool ImGui_ImplSDL3_InitForMetal(SDL_Window* window);

IMGUI_IMPL_API bool ImGui_ImplSDL3_InitForSDLRenderer(
    SDL_Window* window,
    SDL_Renderer* renderer
    );

IMGUI_IMPL_API bool ImGui_ImplSDL3_InitForSDLGPU(SDL_Window* window);
IMGUI_IMPL_API bool ImGui_ImplSDL3_InitForOther(SDL_Window* window);
IMGUI_IMPL_API void ImGui_ImplSDL3_Shutdown();
IMGUI_IMPL_API void ImGui_ImplSDL3_NewFrame();
IMGUI_IMPL_API bool ImGui_ImplSDL3_ProcessEvent(const SDL_Event* event);

IMGUI_IMPL_API void ImGui_ImplSDL3_SetGamepadMode(
    ImGui_ImplSDL3_GamepadMode mode,
    SDL_Gamepad** manual_gamepads_array = nullptr,
    int manual_gamepads_count = -1
    );

IMGUI_IMPL_API void ImGui_ImplSDL3_SetMouseCaptureMode(ImGui_ImplSDL3_MouseCaptureMode mode);
static void ImGui_ImplSDLGPU3_DestroyFrameData();
static ImGui_ImplSDLGPU3_Data* ImGui_ImplSDLGPU3_GetBackendData();

static void ImGui_ImplSDLGPU3_SetupRenderState(
    ImDrawData* draw_data,
    ImGui_ImplSDLGPU3_RenderState* render_state,
    SDL_GPUGraphicsPipeline* pipeline,
    SDL_GPUCommandBuffer* command_buffer,
    SDL_GPURenderPass* render_pass,
    ImGui_ImplSDLGPU3_FrameData* fd,
    uint32_t fb_width,
    uint32_t fb_height
    );

static void CreateOrResizeBuffers(
    SDL_GPUBuffer** buffer,
    SDL_GPUTransferBuffer** transferbuffer,
    uint32_t* old_size,
    uint32_t new_size,
    SDL_GPUBufferUsageFlags usage
    );

void ImGui_ImplSDLGPU3_PrepareDrawData(
    ImDrawData* draw_data,
    SDL_GPUCommandBuffer* command_buffer
    );

void ImGui_ImplSDLGPU3_RenderDrawData(
    ImDrawData* draw_data,
    SDL_GPUCommandBuffer* command_buffer,
    SDL_GPURenderPass* render_pass,
    SDL_GPUGraphicsPipeline* pipeline
    );

static void ImGui_ImplSDLGPU3_DestroyTexture(ImTextureData* tex);
void ImGui_ImplSDLGPU3_UpdateTexture(ImTextureData* tex);
static void ImGui_ImplSDLGPU3_CreateShaders();
static void ImGui_ImplSDLGPU3_CreateGraphicsPipeline();
void ImGui_ImplSDLGPU3_CreateDeviceObjects();
void ImGui_ImplSDLGPU3_DestroyDeviceObjects();
static void ImGui_ImplSDLGPU3_InitMultiViewportSupport();
static void ImGui_ImplSDLGPU3_ShutdownMultiViewportSupport();
bool ImGui_ImplSDLGPU3_Init(ImGui_ImplSDLGPU3_InitInfo* info);
void ImGui_ImplSDLGPU3_Shutdown();
void ImGui_ImplSDLGPU3_NewFrame();
static void ImGui_ImplSDLGPU3_CreateWindow(ImGuiViewport* viewport);

static void ImGui_ImplSDLGPU3_RenderWindow(
    ImGuiViewport* viewport,
    void*
    );

static void ImGui_ImplSDLGPU3_DestroyWindow(ImGuiViewport* viewport);
IMGUI_IMPL_API bool ImGui_ImplSDLGPU3_Init(ImGui_ImplSDLGPU3_InitInfo* info);
IMGUI_IMPL_API void ImGui_ImplSDLGPU3_Shutdown();
IMGUI_IMPL_API void ImGui_ImplSDLGPU3_NewFrame();

IMGUI_IMPL_API void ImGui_ImplSDLGPU3_PrepareDrawData(
    ImDrawData* draw_data,
    SDL_GPUCommandBuffer* command_buffer
    );

IMGUI_IMPL_API void ImGui_ImplSDLGPU3_RenderDrawData(
    ImDrawData* draw_data,
    SDL_GPUCommandBuffer* command_buffer,
    SDL_GPURenderPass* render_pass,
    SDL_GPUGraphicsPipeline* pipeline = nullptr
    );

IMGUI_IMPL_API void ImGui_ImplSDLGPU3_CreateDeviceObjects();
IMGUI_IMPL_API void ImGui_ImplSDLGPU3_DestroyDeviceObjects();
IMGUI_IMPL_API void ImGui_ImplSDLGPU3_UpdateTexture(ImTextureData* tex);
static ImGui_ImplSDLRenderer2_Data* ImGui_ImplSDLRenderer2_GetBackendData();
bool ImGui_ImplSDLRenderer2_Init(SDL_Renderer* renderer);
void ImGui_ImplSDLRenderer2_Shutdown();
static void ImGui_ImplSDLRenderer2_SetupRenderState(SDL_Renderer* renderer);
void ImGui_ImplSDLRenderer2_NewFrame();

void ImGui_ImplSDLRenderer2_RenderDrawData(
    ImDrawData* draw_data,
    SDL_Renderer* renderer
    );

void ImGui_ImplSDLRenderer2_UpdateTexture(ImTextureData* tex);
void ImGui_ImplSDLRenderer2_CreateDeviceObjects();
void ImGui_ImplSDLRenderer2_DestroyDeviceObjects();
IMGUI_IMPL_API bool ImGui_ImplSDLRenderer2_Init(SDL_Renderer* renderer);
IMGUI_IMPL_API void ImGui_ImplSDLRenderer2_Shutdown();
IMGUI_IMPL_API void ImGui_ImplSDLRenderer2_NewFrame();

IMGUI_IMPL_API void ImGui_ImplSDLRenderer2_RenderDrawData(
    ImDrawData* draw_data,
    SDL_Renderer* renderer
    );

IMGUI_IMPL_API void ImGui_ImplSDLRenderer2_CreateDeviceObjects();
IMGUI_IMPL_API void ImGui_ImplSDLRenderer2_DestroyDeviceObjects();
IMGUI_IMPL_API void ImGui_ImplSDLRenderer2_UpdateTexture(ImTextureData* tex);
static ImGui_ImplSDLRenderer3_Data* ImGui_ImplSDLRenderer3_GetBackendData();
bool ImGui_ImplSDLRenderer3_Init(SDL_Renderer* renderer);
void ImGui_ImplSDLRenderer3_Shutdown();
static void ImGui_ImplSDLRenderer3_SetupRenderState(SDL_Renderer* renderer);
void ImGui_ImplSDLRenderer3_NewFrame();

static int SDL_RenderGeometryRaw8BitColor(
    SDL_Renderer* renderer,
    ImVector<SDL_FColor>& colors_out,
    SDL_Texture* texture,
    const float* xy,
    int xy_stride,
    const SDL_Color* color,
    int color_stride,
    const float* uv,
    int uv_stride,
    int num_vertices,
    const void* indices,
    int num_indices,
    int size_indices
    );

void ImGui_ImplSDLRenderer3_RenderDrawData(
    ImDrawData* draw_data,
    SDL_Renderer* renderer
    );

void ImGui_ImplSDLRenderer3_UpdateTexture(ImTextureData* tex);
void ImGui_ImplSDLRenderer3_CreateDeviceObjects();
void ImGui_ImplSDLRenderer3_DestroyDeviceObjects();
IMGUI_IMPL_API bool ImGui_ImplSDLRenderer3_Init(SDL_Renderer* renderer);
IMGUI_IMPL_API void ImGui_ImplSDLRenderer3_Shutdown();
IMGUI_IMPL_API void ImGui_ImplSDLRenderer3_NewFrame();

IMGUI_IMPL_API void ImGui_ImplSDLRenderer3_RenderDrawData(
    ImDrawData* draw_data,
    SDL_Renderer* renderer
    );

IMGUI_IMPL_API void ImGui_ImplSDLRenderer3_CreateDeviceObjects();
IMGUI_IMPL_API void ImGui_ImplSDLRenderer3_DestroyDeviceObjects();
IMGUI_IMPL_API void ImGui_ImplSDLRenderer3_UpdateTexture(ImTextureData* tex);
bool ImGui_ImplVulkan_CreateDeviceObjects();
void ImGui_ImplVulkan_DestroyDeviceObjects();

void ImGui_ImplVulkan_DestroyFrameRenderBuffers(
    VkDevice device,
    ImGui_ImplVulkan_FrameRenderBuffers* buffers,
    const VkAllocationCallbacks* allocator
    );

void ImGui_ImplVulkan_DestroyWindowRenderBuffers(
    VkDevice device,
    ImGui_ImplVulkan_WindowRenderBuffers* buffers,
    const VkAllocationCallbacks* allocator
    );

void ImGui_ImplVulkanH_DestroyFrame(
    VkDevice device,
    ImGui_ImplVulkanH_Frame* fd,
    const VkAllocationCallbacks* allocator
    );

void ImGui_ImplVulkanH_DestroyFrameSemaphores(
    VkDevice device,
    ImGui_ImplVulkanH_FrameSemaphores* fsd,
    const VkAllocationCallbacks* allocator
    );

void ImGui_ImplVulkanH_DestroyAllViewportsRenderBuffers(
    VkDevice device,
    const VkAllocationCallbacks* allocator
    );

void ImGui_ImplVulkanH_CreateWindowSwapChain(
    VkPhysicalDevice physical_device,
    VkDevice device,
    ImGui_ImplVulkanH_Window* wd,
    const VkAllocationCallbacks* allocator,
    int w,
    int h,
    uint32_t min_image_count,
    VkImageUsageFlags image_usage
    );

void ImGui_ImplVulkanH_CreateWindowCommandBuffers(
    VkPhysicalDevice physical_device,
    VkDevice device,
    ImGui_ImplVulkanH_Window* wd,
    uint32_t queue_family,
    const VkAllocationCallbacks* allocator
    );

static void ImGui_ImplVulkan_InitMultiViewportSupport();
static void ImGui_ImplVulkan_ShutdownMultiViewportSupport();
static ImGui_ImplVulkan_Data* ImGui_ImplVulkan_GetBackendData();

static uint32_t ImGui_ImplVulkan_MemoryType(
    VkMemoryPropertyFlags properties,
    uint32_t type_bits
    );

static void check_vk_result(VkResult err);

static VkDeviceSize AlignBufferSize(
    VkDeviceSize size,
    VkDeviceSize alignment
    );

static void CreateOrResizeBuffer(
    VkBuffer& buffer,
    VkDeviceMemory& buffer_memory,
    VkDeviceSize& buffer_size,
    VkDeviceSize new_size,
    VkBufferUsageFlagBits usage
    );

static void ImGui_ImplVulkan_SetupRenderState(
    ImDrawData* draw_data,
    VkPipeline pipeline,
    VkCommandBuffer command_buffer,
    ImGui_ImplVulkan_FrameRenderBuffers* rb,
    int fb_width,
    int fb_height
    );

void ImGui_ImplVulkan_RenderDrawData(
    ImDrawData* draw_data,
    VkCommandBuffer command_buffer,
    VkPipeline pipeline
    );

static void ImGui_ImplVulkan_DestroyTexture(ImTextureData* tex);
void ImGui_ImplVulkan_UpdateTexture(ImTextureData* tex);

static void ImGui_ImplVulkan_CreateShaderModules(
    VkDevice device,
    const VkAllocationCallbacks* allocator
    );

static VkPipeline ImGui_ImplVulkan_CreatePipeline(
    VkDevice device,
    const VkAllocationCallbacks* allocator,
    VkPipelineCache pipelineCache,
    const ImGui_ImplVulkan_PipelineInfo* info
    );

void ImGui_ImplVulkan_CreateMainPipeline(const ImGui_ImplVulkan_PipelineInfo* pipeline_info_in);
static uint32_t ImGui_ImplVulkan_GetDefaultApiVersion();

bool ImGui_ImplVulkan_LoadFunctions(
    uint32_t api_version,
    PFN_vkVoidFunction(*)(const char*function_name, void*user_data) loader_func,
    void* user_data
    );

bool ImGui_ImplVulkan_Init(ImGui_ImplVulkan_InitInfo* info);
void ImGui_ImplVulkan_Shutdown();
void ImGui_ImplVulkan_NewFrame();
void ImGui_ImplVulkan_SetMinImageCount(uint32_t min_image_count);

VkDescriptorSet ImGui_ImplVulkan_AddTexture(
    VkSampler sampler,
    VkImageView image_view,
    VkImageLayout image_layout
    );

void ImGui_ImplVulkan_RemoveTexture(VkDescriptorSet descriptor_set);

VkSurfaceFormatKHR ImGui_ImplVulkanH_SelectSurfaceFormat(
    VkPhysicalDevice physical_device,
    VkSurfaceKHR surface,
    const VkFormat* request_formats,
    int request_formats_count,
    VkColorSpaceKHR request_color_space
    );

VkPresentModeKHR ImGui_ImplVulkanH_SelectPresentMode(
    VkPhysicalDevice physical_device,
    VkSurfaceKHR surface,
    const VkPresentModeKHR* request_modes,
    int request_modes_count
    );

VkPhysicalDevice ImGui_ImplVulkanH_SelectPhysicalDevice(VkInstance instance);
uint32_t ImGui_ImplVulkanH_SelectQueueFamilyIndex(VkPhysicalDevice physical_device);
int ImGui_ImplVulkanH_GetMinImageCountFromPresentMode(VkPresentModeKHR present_mode);

void ImGui_ImplVulkanH_CreateOrResizeWindow(
    VkInstance instance,
    VkPhysicalDevice physical_device,
    VkDevice device,
    ImGui_ImplVulkanH_Window* wd,
    uint32_t queue_family,
    const VkAllocationCallbacks* allocator,
    int width,
    int height,
    uint32_t min_image_count,
    VkImageUsageFlags image_usage
    );

void ImGui_ImplVulkanH_DestroyWindow(
    VkInstance instance,
    VkDevice device,
    ImGui_ImplVulkanH_Window* wd,
    const VkAllocationCallbacks* allocator
    );

ImGui_ImplVulkanH_Window* ImGui_ImplVulkanH_GetWindowDataFromViewport(ImGuiViewport* viewport);
static void ImGui_ImplVulkan_CreateWindow(ImGuiViewport* viewport);
static void ImGui_ImplVulkan_DestroyWindow(ImGuiViewport* viewport);

static void ImGui_ImplVulkan_SetWindowSize(
    ImGuiViewport* viewport,
    ImVec2 size
    );

static void ImGui_ImplVulkan_RenderWindow(
    ImGuiViewport* viewport,
    void*
    );

static void ImGui_ImplVulkan_SwapBuffers(
    ImGuiViewport* viewport,
    void*
    );

IMGUI_IMPL_API bool ImGui_ImplVulkan_Init(ImGui_ImplVulkan_InitInfo* info);
IMGUI_IMPL_API void ImGui_ImplVulkan_Shutdown();
IMGUI_IMPL_API void ImGui_ImplVulkan_NewFrame();

IMGUI_IMPL_API void ImGui_ImplVulkan_RenderDrawData(
    ImDrawData* draw_data,
    VkCommandBuffer command_buffer,
    VkPipeline pipeline = VK_NULL_HANDLE
    );

IMGUI_IMPL_API void ImGui_ImplVulkan_SetMinImageCount(uint32_t min_image_count);
IMGUI_IMPL_API void ImGui_ImplVulkan_CreateMainPipeline(const ImGui_ImplVulkan_PipelineInfo* info);
IMGUI_IMPL_API void ImGui_ImplVulkan_UpdateTexture(ImTextureData* tex);

IMGUI_IMPL_API VkDescriptorSet ImGui_ImplVulkan_AddTexture(
    VkSampler sampler,
    VkImageView image_view,
    VkImageLayout image_layout
    );

IMGUI_IMPL_API void ImGui_ImplVulkan_RemoveTexture(VkDescriptorSet descriptor_set);

IMGUI_IMPL_API bool ImGui_ImplVulkan_LoadFunctions(
    uint32_t api_version,
    PFN_vkVoidFunction(*)(const char*function_name, void*user_data) loader_func,
    void* user_data = nullptr
    );

IMGUI_IMPL_API void ImGui_ImplVulkanH_CreateOrResizeWindow(
    VkInstance instance,
    VkPhysicalDevice physical_device,
    VkDevice device,
    ImGui_ImplVulkanH_Window* wd,
    uint32_t queue_family,
    const VkAllocationCallbacks* allocator,
    int w,
    int h,
    uint32_t min_image_count,
    VkImageUsageFlags image_usage
    );

IMGUI_IMPL_API void ImGui_ImplVulkanH_DestroyWindow(
    VkInstance instance,
    VkDevice device,
    ImGui_ImplVulkanH_Window* wd,
    const VkAllocationCallbacks* allocator
    );

IMGUI_IMPL_API VkSurfaceFormatKHR ImGui_ImplVulkanH_SelectSurfaceFormat(
    VkPhysicalDevice physical_device,
    VkSurfaceKHR surface,
    const VkFormat* request_formats,
    int request_formats_count,
    VkColorSpaceKHR request_color_space
    );

IMGUI_IMPL_API VkPresentModeKHR ImGui_ImplVulkanH_SelectPresentMode(
    VkPhysicalDevice physical_device,
    VkSurfaceKHR surface,
    const VkPresentModeKHR* request_modes,
    int request_modes_count
    );

IMGUI_IMPL_API VkPhysicalDevice ImGui_ImplVulkanH_SelectPhysicalDevice(VkInstance instance);
IMGUI_IMPL_API uint32_t ImGui_ImplVulkanH_SelectQueueFamilyIndex(VkPhysicalDevice physical_device);
IMGUI_IMPL_API int ImGui_ImplVulkanH_GetMinImageCountFromPresentMode(VkPresentModeKHR present_mode);
IMGUI_IMPL_API ImGui_ImplVulkanH_Window* ImGui_ImplVulkanH_GetWindowDataFromViewport(ImGuiViewport* viewport);

ImGuiID ImHashData(
    const void* data_p,
    size_t data_size,
    ImU32 seed
    );

static ImGui_ImplWGPU_Data* ImGui_ImplWGPU_GetBackendData();
static void SafeRelease(ImDrawIdx*& res);
static void SafeRelease(ImDrawVert*& res);
static void SafeRelease(WGPUBindGroupLayout& res);
static void SafeRelease(WGPUBindGroup& res);
static void SafeRelease(WGPUBuffer& res);
static void SafeRelease(WGPUPipelineLayout& res);
static void SafeRelease(WGPURenderPipeline& res);
static void SafeRelease(WGPUSampler& res);
static void SafeRelease(WGPUShaderModule& res);
static void SafeRelease(RenderResources& res);
static void SafeRelease(FrameResources& res);
static WGPUProgrammableStageDescriptor ImGui_ImplWGPU_CreateShaderModule(const char* wgsl_source);

static WGPUBindGroup ImGui_ImplWGPU_CreateImageBindGroup(
    WGPUBindGroupLayout layout,
    WGPUTextureView texture
    );

static void ImGui_ImplWGPU_SetupRenderState(
    ImDrawData* draw_data,
    WGPURenderPassEncoder ctx,
    FrameResources* fr
    );

void ImGui_ImplWGPU_RenderDrawData(
    ImDrawData* draw_data,
    WGPURenderPassEncoder pass_encoder
    );

static void ImGui_ImplWGPU_DestroyTexture(ImTextureData* tex);
void ImGui_ImplWGPU_UpdateTexture(ImTextureData* tex);
static void ImGui_ImplWGPU_CreateUniformBuffer();
bool ImGui_ImplWGPU_CreateDeviceObjects();
void ImGui_ImplWGPU_InvalidateDeviceObjects();
bool ImGui_ImplWGPU_Init(ImGui_ImplWGPU_InitInfo* init_info);
void ImGui_ImplWGPU_Shutdown();
void ImGui_ImplWGPU_NewFrame();
bool ImGui_ImplWGPU_IsSurfaceStatusError(WGPUSurfaceGetCurrentTextureStatus status);
bool ImGui_ImplWGPU_IsSurfaceStatusSubOptimal(WGPUSurfaceGetCurrentTextureStatus status);
const char* ImGui_ImplWGPU_GetLogLevelName(WGPULogLevel level);
const char* ImGui_ImplWGPU_GetBackendTypeName(WGPUBackendType type);
const char* ImGui_ImplWGPU_GetAdapterTypeName(WGPUAdapterType type);
void ImGui_ImplWGPU_DebugPrintAdapterInfo(const WGPUAdapter& adapter);
WGPUSurface ImGui_ImplWGPU_CreateWGPUSurfaceHelper(ImGui_ImplWGPU_CreateSurfaceInfo* info);
IMGUI_IMPL_API bool ImGui_ImplWGPU_Init(ImGui_ImplWGPU_InitInfo* init_info);
IMGUI_IMPL_API void ImGui_ImplWGPU_Shutdown();
IMGUI_IMPL_API void ImGui_ImplWGPU_NewFrame();

IMGUI_IMPL_API void ImGui_ImplWGPU_RenderDrawData(
    ImDrawData* draw_data,
    WGPURenderPassEncoder pass_encoder
    );

IMGUI_IMPL_API bool ImGui_ImplWGPU_CreateDeviceObjects();
IMGUI_IMPL_API void ImGui_ImplWGPU_InvalidateDeviceObjects();
IMGUI_IMPL_API void ImGui_ImplWGPU_UpdateTexture(ImTextureData* tex);
bool ImGui_ImplWGPU_IsSurfaceStatusError(WGPUSurfaceGetCurrentTextureStatus status);
bool ImGui_ImplWGPU_IsSurfaceStatusSubOptimal(WGPUSurfaceGetCurrentTextureStatus status);
void ImGui_ImplWGPU_DebugPrintAdapterInfo(const WGPUAdapter& adapter);
const char* ImGui_ImplWGPU_GetBackendTypeName(WGPUBackendType type);
const char* ImGui_ImplWGPU_GetAdapterTypeName(WGPUAdapterType type);
WGPUSurface ImGui_ImplWGPU_CreateWGPUSurfaceHelper(ImGui_ImplWGPU_CreateSurfaceInfo* info);
static void ImGui_ImplWin32_InitMultiViewportSupport(bool platform_has_own_dc);
static void ImGui_ImplWin32_ShutdownMultiViewportSupport();
static void ImGui_ImplWin32_UpdateMonitors();
static ImGui_ImplWin32_Data* ImGui_ImplWin32_GetBackendData();
static ImGui_ImplWin32_Data* ImGui_ImplWin32_GetBackendData(ImGuiIO& io);
static void ImGui_ImplWin32_UpdateKeyboardCodePage(ImGuiIO& io);

static bool ImGui_ImplWin32_InitEx(
    void* hwnd,
    bool platform_has_own_dc
    );

IMGUI_IMPL_API bool ImGui_ImplWin32_Init(void* hwnd);
IMGUI_IMPL_API bool ImGui_ImplWin32_InitForOpenGL(void* hwnd);
void ImGui_ImplWin32_Shutdown();

static bool ImGui_ImplWin32_UpdateMouseCursor(
    ImGuiIO& io,
    ImGuiMouseCursor imgui_cursor
    );

static bool IsVkDown(int vk);

static void ImGui_ImplWin32_AddKeyEvent(
    ImGuiIO& io,
    ImGuiKey key,
    bool down,
    int native_keycode,
    int native_scancode = -1
    );

static void ImGui_ImplWin32_ProcessKeyEventsWorkarounds(ImGuiIO& io);
static void ImGui_ImplWin32_UpdateKeyModifiers(ImGuiIO& io);

static ImGuiViewport* ImGui_ImplWin32_FindViewportByPlatformHandle(
    ImGuiPlatformIO& platform_io,
    HWND hwnd
    );

static void ImGui_ImplWin32_UpdateMouseData(
    ImGuiIO& io,
    ImGuiPlatformIO& platform_io
    );

static void ImGui_ImplWin32_UpdateGamepads(ImGuiIO& io);

static BOOL CALLBACK ImGui_ImplWin32_UpdateMonitors_EnumFunc(
    HMONITOR monitor,
    HDC,
    LPRECT,
    LPARAM
    );

void ImGui_ImplWin32_NewFrame();

ImGuiKey ImGui_ImplWin32_KeyEventToImGuiKey(
    WPARAM wParam,
    LPARAM lParam
    );

static ImGuiMouseSource ImGui_ImplWin32_GetMouseSourceFromMessageExtraInfo();

IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(
    HWND hWnd,
    UINT msg,
    WPARAM wParam,
    LPARAM lParam
    );

IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandlerEx(
    HWND hWnd,
    UINT msg,
    WPARAM wParam,
    LPARAM lParam,
    ImGuiIO& io
    );

static BOOL _IsWindowsVersionOrGreater(
    WORD major,
    WORD minor,
    WORD
    );

DECLARE_HANDLE(DPI_AWARENESS_CONTEXT);
void ImGui_ImplWin32_EnableDpiAwareness();
float ImGui_ImplWin32_GetDpiScaleForMonitor(void* monitor);
float ImGui_ImplWin32_GetDpiScaleForHwnd(void* hwnd);
void ImGui_ImplWin32_EnableAlphaCompositing(void* hwnd);

static void ImGui_ImplWin32_GetWin32StyleFromViewportFlags(
    ImGuiViewportFlags flags,
    DWORD* out_style,
    DWORD* out_ex_style
    );

static HWND ImGui_ImplWin32_GetHwndFromViewport(ImGuiViewport* viewport);
static void ImGui_ImplWin32_CreateWindow(ImGuiViewport* viewport);
static void ImGui_ImplWin32_DestroyWindow(ImGuiViewport* viewport);
static void ImGui_ImplWin32_ShowWindow(ImGuiViewport* viewport);
static void ImGui_ImplWin32_UpdateWindow(ImGuiViewport* viewport);
static ImVec2 ImGui_ImplWin32_GetWindowPos(ImGuiViewport* viewport);
static void ImGui_ImplWin32_UpdateWin32StyleFromWindow(ImGuiViewport* viewport);

static void ImGui_ImplWin32_SetWindowPos(
    ImGuiViewport* viewport,
    ImVec2 pos
    );

static ImVec2 ImGui_ImplWin32_GetWindowSize(ImGuiViewport* viewport);

static void ImGui_ImplWin32_SetWindowSize(
    ImGuiViewport* viewport,
    ImVec2 size
    );

static void ImGui_ImplWin32_SetWindowFocus(ImGuiViewport* viewport);
static bool ImGui_ImplWin32_GetWindowFocus(ImGuiViewport* viewport);
static bool ImGui_ImplWin32_GetWindowMinimized(ImGuiViewport* viewport);

static void ImGui_ImplWin32_SetWindowTitle(
    ImGuiViewport* viewport,
    const char* title
    );

static void ImGui_ImplWin32_SetWindowAlpha(
    ImGuiViewport* viewport,
    float alpha
    );

static float ImGui_ImplWin32_GetWindowDpiScale(ImGuiViewport* viewport);
static void ImGui_ImplWin32_OnChangedViewport(ImGuiViewport* viewport);

static LRESULT CALLBACK ImGui_ImplWin32_WndProcHandler_PlatformWindow(
    HWND hWnd,
    UINT msg,
    WPARAM wParam,
    LPARAM lParam
    );

IMGUI_IMPL_API bool ImGui_ImplWin32_Init(void* hwnd);
IMGUI_IMPL_API bool ImGui_ImplWin32_InitForOpenGL(void* hwnd);
IMGUI_IMPL_API void ImGui_ImplWin32_Shutdown();
IMGUI_IMPL_API void ImGui_ImplWin32_NewFrame();
IMGUI_IMPL_API void ImGui_ImplWin32_EnableDpiAwareness();
IMGUI_IMPL_API float ImGui_ImplWin32_GetDpiScaleForHwnd(void* hwnd);
IMGUI_IMPL_API float ImGui_ImplWin32_GetDpiScaleForMonitor(void* monitor);
IMGUI_IMPL_API void ImGui_ImplWin32_EnableAlphaCompositing(void* hwnd);
GLFWAPI int glfwInit(void);
GLFWAPI void glfwTerminate(void);
GLFWAPI void glfwGetVersion(int* major, int* minor, int* rev);
GLFWAPI const char* glfwGetVersionString(void);
GLFWAPI GLFWerrorfun glfwSetErrorCallback(GLFWerrorfun cbfun);
GLFWAPI GLFWmonitor** glfwGetMonitors(int* count);
GLFWAPI GLFWmonitor* glfwGetPrimaryMonitor(void);
GLFWAPI void glfwGetMonitorPos(GLFWmonitor* monitor, int* xpos, int* ypos);
GLFWAPI void glfwGetMonitorPhysicalSize(GLFWmonitor* monitor, int* widthMM, int* heightMM);
GLFWAPI const char* glfwGetMonitorName(GLFWmonitor* monitor);
GLFWAPI GLFWmonitorfun glfwSetMonitorCallback(GLFWmonitorfun cbfun);
GLFWAPI const GLFWvidmode* glfwGetVideoModes(GLFWmonitor* monitor, int* count);
GLFWAPI const GLFWvidmode* glfwGetVideoMode(GLFWmonitor* monitor);
GLFWAPI void glfwSetGamma(GLFWmonitor* monitor, float gamma);
GLFWAPI const GLFWgammaramp* glfwGetGammaRamp(GLFWmonitor* monitor);
GLFWAPI void glfwSetGammaRamp(GLFWmonitor* monitor, const GLFWgammaramp* ramp);
GLFWAPI void glfwDefaultWindowHints(void);
GLFWAPI void glfwWindowHint(int hint, int value);
GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height, const char* title, GLFWmonitor* monitor, GLFWwindow* share);
GLFWAPI void glfwDestroyWindow(GLFWwindow* window);
GLFWAPI int glfwWindowShouldClose(GLFWwindow* window);
GLFWAPI void glfwSetWindowShouldClose(GLFWwindow* window, int value);
GLFWAPI void glfwSetWindowTitle(GLFWwindow* window, const char* title);
GLFWAPI void glfwSetWindowIcon(GLFWwindow* window, int count, const GLFWimage* images);
GLFWAPI void glfwGetWindowPos(GLFWwindow* window, int* xpos, int* ypos);
GLFWAPI void glfwSetWindowPos(GLFWwindow* window, int xpos, int ypos);
GLFWAPI void glfwGetWindowSize(GLFWwindow* window, int* width, int* height);
GLFWAPI void glfwSetWindowSizeLimits(GLFWwindow* window, int minwidth, int minheight, int maxwidth, int maxheight);
GLFWAPI void glfwSetWindowAspectRatio(GLFWwindow* window, int numer, int denom);
GLFWAPI void glfwSetWindowSize(GLFWwindow* window, int width, int height);
GLFWAPI void glfwGetFramebufferSize(GLFWwindow* window, int* width, int* height);
GLFWAPI void glfwGetWindowFrameSize(GLFWwindow* window, int* left, int* top, int* right, int* bottom);
GLFWAPI void glfwIconifyWindow(GLFWwindow* window);
GLFWAPI void glfwRestoreWindow(GLFWwindow* window);
GLFWAPI void glfwMaximizeWindow(GLFWwindow* window);
GLFWAPI void glfwShowWindow(GLFWwindow* window);
GLFWAPI void glfwHideWindow(GLFWwindow* window);
GLFWAPI void glfwFocusWindow(GLFWwindow* window);
GLFWAPI GLFWmonitor* glfwGetWindowMonitor(GLFWwindow* window);

GLFWAPI void glfwSetWindowMonitor(
    GLFWwindow* window,
    GLFWmonitor* monitor,
    int xpos,
    int ypos,
    int width,
    int height,
    int refreshRate
    );

GLFWAPI int glfwGetWindowAttrib(GLFWwindow* window, int attrib);
GLFWAPI void glfwSetWindowUserPointer(GLFWwindow* window, void* pointer);
GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow* window);
GLFWAPI GLFWwindowposfun glfwSetWindowPosCallback(GLFWwindow* window, GLFWwindowposfun cbfun);
GLFWAPI GLFWwindowsizefun glfwSetWindowSizeCallback(GLFWwindow* window, GLFWwindowsizefun cbfun);
GLFWAPI GLFWwindowclosefun glfwSetWindowCloseCallback(GLFWwindow* window, GLFWwindowclosefun cbfun);
GLFWAPI GLFWwindowrefreshfun glfwSetWindowRefreshCallback(GLFWwindow* window, GLFWwindowrefreshfun cbfun);
GLFWAPI GLFWwindowfocusfun glfwSetWindowFocusCallback(GLFWwindow* window, GLFWwindowfocusfun cbfun);
GLFWAPI GLFWwindowiconifyfun glfwSetWindowIconifyCallback(GLFWwindow* window, GLFWwindowiconifyfun cbfun);
GLFWAPI GLFWframebuffersizefun glfwSetFramebufferSizeCallback(GLFWwindow* window, GLFWframebuffersizefun cbfun);
GLFWAPI void glfwPollEvents(void);
GLFWAPI void glfwWaitEvents(void);
GLFWAPI void glfwWaitEventsTimeout(double timeout);
GLFWAPI void glfwPostEmptyEvent(void);
GLFWAPI int glfwGetInputMode(GLFWwindow* window, int mode);
GLFWAPI void glfwSetInputMode(GLFWwindow* window, int mode, int value);
GLFWAPI const char* glfwGetKeyName(int key, int scancode);
GLFWAPI int glfwGetKey(GLFWwindow* window, int key);
GLFWAPI int glfwGetMouseButton(GLFWwindow* window, int button);
GLFWAPI void glfwGetCursorPos(GLFWwindow* window, double* xpos, double* ypos);
GLFWAPI void glfwSetCursorPos(GLFWwindow* window, double xpos, double ypos);
GLFWAPI GLFWcursor* glfwCreateCursor(const GLFWimage* image, int xhot, int yhot);
GLFWAPI GLFWcursor* glfwCreateStandardCursor(int shape);
GLFWAPI void glfwDestroyCursor(GLFWcursor* cursor);
GLFWAPI void glfwSetCursor(GLFWwindow* window, GLFWcursor* cursor);
GLFWAPI GLFWkeyfun glfwSetKeyCallback(GLFWwindow* window, GLFWkeyfun cbfun);
GLFWAPI GLFWcharfun glfwSetCharCallback(GLFWwindow* window, GLFWcharfun cbfun);
GLFWAPI GLFWcharmodsfun glfwSetCharModsCallback(GLFWwindow* window, GLFWcharmodsfun cbfun);
GLFWAPI GLFWmousebuttonfun glfwSetMouseButtonCallback(GLFWwindow* window, GLFWmousebuttonfun cbfun);
GLFWAPI GLFWcursorposfun glfwSetCursorPosCallback(GLFWwindow* window, GLFWcursorposfun cbfun);
GLFWAPI GLFWcursorenterfun glfwSetCursorEnterCallback(GLFWwindow* window, GLFWcursorenterfun cbfun);
GLFWAPI GLFWscrollfun glfwSetScrollCallback(GLFWwindow* window, GLFWscrollfun cbfun);
GLFWAPI GLFWdropfun glfwSetDropCallback(GLFWwindow* window, GLFWdropfun cbfun);
GLFWAPI int glfwJoystickPresent(int joy);
GLFWAPI const float* glfwGetJoystickAxes(int joy, int* count);
GLFWAPI const unsigned char* glfwGetJoystickButtons(int joy, int* count);
GLFWAPI const char* glfwGetJoystickName(int joy);
GLFWAPI GLFWjoystickfun glfwSetJoystickCallback(GLFWjoystickfun cbfun);
GLFWAPI void glfwSetClipboardString(GLFWwindow* window, const char* string);
GLFWAPI const char* glfwGetClipboardString(GLFWwindow* window);
GLFWAPI double glfwGetTime(void);
GLFWAPI void glfwSetTime(double time);
GLFWAPI uint64_t glfwGetTimerValue(void);
GLFWAPI uint64_t glfwGetTimerFrequency(void);
GLFWAPI void glfwMakeContextCurrent(GLFWwindow* window);
GLFWAPI GLFWwindow* glfwGetCurrentContext(void);
GLFWAPI void glfwSwapBuffers(GLFWwindow* window);
GLFWAPI void glfwSwapInterval(int interval);
GLFWAPI int glfwExtensionSupported(const char* extension);
GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname);
GLFWAPI int glfwVulkanSupported(void);
GLFWAPI const char** glfwGetRequiredInstanceExtensions(uint32_t* count);
static int16_t sNetToNative16(const unsigned char* value);
static int32_t sNetToNative32(const unsigned char* value);
static void sTrace(uSynergyContext* context, const char* text);
static void sAddString(uSynergyContext* context, const char* string);
static void sAddUInt8(uSynergyContext* context, uint8_t value);
static void sAddUInt16(uSynergyContext* context, uint16_t value);
static void sAddUInt32(uSynergyContext* context, uint32_t value);
static uSynergyBool sSendReply(uSynergyContext* context);
static void sSendMouseCallback(uSynergyContext* context);
static void sSendKeyboardCallback(uSynergyContext* context, uint16_t key, uint16_t modifiers, uSynergyBool down, uSynergyBool repeat);
static void sSendJoystickCallback(uSynergyContext* context, uint8_t joyNum);

static void sProcessMessage(
    uSynergyContext* context,
    const uint8_t* message
    );

static void sSetDisconnected(uSynergyContext* context);
static void sUpdateContext(uSynergyContext* context);
void uSynergyInit(uSynergyContext* context);
void uSynergyUpdate(uSynergyContext* context);
void uSynergySendClipboard(uSynergyContext* context, const char* text);
void uSynergyInit(uSynergyContext* context);
void uSynergyUpdate(uSynergyContext* context);
void uSynergySendClipboard(uSynergyContext* context, const char* text);
static void SetCurrentWindow(ImGuiWindow* window);

static ImGuiWindow* CreateNewWindow(
    const char* name,
    ImGuiWindowFlags flags
    );

static ImVec2 CalcNextScrollFromScrollTargetAndClamp(ImGuiWindow* window);

static void AddWindowToSortBuffer(
    ImVector<ImGuiWindow*>* out_sorted_windows,
    ImGuiWindow* window
    );

static void WindowSettingsHandler_ClearAll(
    ImGuiContext* ctx,
    ImGuiSettingsHandler*
    );

static void* WindowSettingsHandler_ReadOpen(
    ImGuiContext*,
    ImGuiSettingsHandler*,
    const char* name
    );

static void WindowSettingsHandler_ReadLine(
    ImGuiContext*,
    ImGuiSettingsHandler*,
    void* entry,
    const char* line
    );

static void WindowSettingsHandler_ApplyAll(
    ImGuiContext* ctx,
    ImGuiSettingsHandler*
    );

static void WindowSettingsHandler_WriteAll(
    ImGuiContext* ctx,
    ImGuiSettingsHandler* handler,
    ImGuiTextBuffer* buf
    );

static const char* Platform_GetClipboardTextFn_DefaultImpl(ImGuiContext* ctx);

static void Platform_SetClipboardTextFn_DefaultImpl(
    ImGuiContext* ctx,
    const char* text
    );

static void Platform_SetImeDataFn_DefaultImpl(
    ImGuiContext* ctx,
    ImGuiViewport* viewport,
    ImGuiPlatformImeData* data
    );

static bool Platform_OpenInShellFn_DefaultImpl(
    ImGuiContext* ctx,
    const char* path
    );

static void* MallocWrapper(
    size_t size,
    void* user_data
    );

static void FreeWrapper(
    void* ptr,
    void* user_data
    );

static ImGuiInputEvent* FindLatestInputEvent(
    ImGuiContext* ctx,
    ImGuiInputEventType type,
    int arg = -1
    );

ImVec2 ImBezierCubicClosestPoint(
    const ImVec2& p1,
    const ImVec2& p2,
    const ImVec2& p3,
    const ImVec2& p4,
    const ImVec2& p,
    int num_segments
    );

static void ImBezierCubicClosestPointCasteljauStep(
    const ImVec2& p,
    ImVec2& p_closest,
    ImVec2& p_last,
    float& p_closest_dist2,
    float x1,
    float y1,
    float x2,
    float y2,
    float x3,
    float y3,
    float x4,
    float y4,
    float tess_tol,
    int level
    );

ImVec2 ImBezierCubicClosestPointCasteljau(
    const ImVec2& p1,
    const ImVec2& p2,
    const ImVec2& p3,
    const ImVec2& p4,
    const ImVec2& p,
    float tess_tol
    );

ImVec2 ImLineClosestPoint(
    const ImVec2& a,
    const ImVec2& b,
    const ImVec2& p
    );

bool ImTriangleContainsPoint(
    const ImVec2& a,
    const ImVec2& b,
    const ImVec2& c,
    const ImVec2& p
    );

void ImTriangleBarycentricCoords(
    const ImVec2& a,
    const ImVec2& b,
    const ImVec2& c,
    const ImVec2& p,
    float& out_u,
    float& out_v,
    float& out_w
    );

ImVec2 ImTriangleClosestPoint(
    const ImVec2& a,
    const ImVec2& b,
    const ImVec2& c,
    const ImVec2& p
    );

int ImStricmp(
    const char* str1,
    const char* str2
    );

int ImStrnicmp(
    const char* str1,
    const char* str2,
    size_t count
    );

void ImStrncpy(
    char* dst,
    const char* src,
    size_t count
    );

char* ImStrdup(const char* str);

void* ImMemdup(
    const void* src,
    size_t size
    );

char* ImStrdupcpy(
    char* dst,
    size_t* p_dst_size,
    const char* src
    );

const char* ImStrchrRange(
    const char* str,
    const char* str_end,
    char c
    );

int ImStrlenW(const ImWchar* str);

const char* ImStreolRange(
    const char* str,
    const char* str_end
    );

const char* ImStrbol(
    const char* buf_mid_line,
    const char* buf_begin
    );

const char* ImStristr(
    const char* haystack,
    const char* haystack_end,
    const char* needle,
    const char* needle_end
    );

void ImStrTrimBlanks(char* buf);
const char* ImStrSkipBlank(const char* str);

int ImFormatString(
    char* buf,
    size_t buf_size,
    const char* fmt,
    ...
    );

int ImFormatStringV(
    char* buf,
    size_t buf_size,
    const char* fmt,
    va_list args
    );

void ImFormatStringToTempBuffer(
    const char** out_buf,
    const char** out_buf_end,
    const char* fmt,
    ...
    );

void ImFormatStringToTempBufferV(
    const char** out_buf,
    const char** out_buf_end,
    const char* fmt,
    va_list args
    );

ImGuiID ImHashData(
    const void* data_p,
    size_t data_size,
    ImGuiID seed
    );

ImGuiID ImHashStr(
    const char* data_p,
    size_t data_size,
    ImGuiID seed
    );

const char* ImHashSkipUncontributingPrefix(const char* label);

ImFileHandle ImFileOpen(
    const char* filename,
    const char* mode
    );

bool ImFileClose(ImFileHandle f);
ImU64 ImFileGetSize(ImFileHandle f);

ImU64 ImFileRead(
    void* data,
    ImU64 sz,
    ImU64 count,
    ImFileHandle f
    );

ImU64 ImFileWrite(
    const void* data,
    ImU64 sz,
    ImU64 count,
    ImFileHandle f
    );

void* ImFileLoadToMemory(
    const char* filename,
    const char* mode,
    size_t* out_file_size,
    int padding_bytes
    );

IM_MSVC_RUNTIME_CHECKS_OFF int ImTextCharFromUtf8(
    unsigned int* out_char,
    const char* in_text,
    const char* in_text_end
    );

int ImTextStrFromUtf8(
    ImWchar* buf,
    int buf_size,
    const char* in_text,
    const char* in_text_end,
    const char** in_text_remaining
    );

int ImTextCountCharsFromUtf8(
    const char* in_text,
    const char* in_text_end
    );

static int ImTextCharToUtf8_inline(
    char* buf,
    int buf_size,
    unsigned int c
    );

int ImTextCharToUtf8(
    char out_buf [5],
    unsigned int c
    );

int ImTextCountUtf8BytesFromChar(
    const char* in_text,
    const char* in_text_end
    );

static int ImTextCountUtf8BytesFromChar(unsigned int c);

int ImTextStrToUtf8(
    char* out_buf,
    int out_buf_size,
    const ImWchar* in_text,
    const ImWchar* in_text_end
    );

int ImTextCountUtf8BytesFromStr(
    const ImWchar* in_text,
    const ImWchar* in_text_end
    );

const char* ImTextFindPreviousUtf8Codepoint(
    const char* in_text_start,
    const char* in_p
    );

const char* ImTextFindValidUtf8CodepointEnd(
    const char* in_text_start,
    const char* in_text_end,
    const char* in_p
    );

int ImTextCountLines(
    const char* in_text,
    const char* in_text_end
    );

IM_MSVC_RUNTIME_CHECKS_RESTORE IMGUI_API ImU32 ImAlphaBlendColors(
    ImU32 col_a,
    ImU32 col_b
    );

ImGuiStoragePair* ImLowerBound(
    ImGuiStoragePair* in_begin,
    ImGuiStoragePair* in_end,
    ImGuiID key
    );

static IM_MSVC_RUNTIME_CHECKS_OFF int IMGUI_CDECL PairComparerByID(
    const void* lhs,
    const void* rhs
    );

static IM_MSVC_RUNTIME_CHECKS_RESTORE bool GetSkipItemForListClipping();

static void ImGuiListClipper_SortAndFuseRanges(
    ImVector<ImGuiListClipperRange>& ranges,
    int offset = 0
    );

static void ImGuiListClipper_SeekCursorAndSetupPrevLine(
    ImGuiListClipper* clipper,
    float pos_y,
    float line_height
    );

static bool ImGuiListClipper_StepInternal(ImGuiListClipper* clipper);
static float CalcDelayFromHoveredFlags(ImGuiHoveredFlags flags);

static ImGuiHoveredFlags ApplyHoverFlagsForTooltip(
    ImGuiHoveredFlags user_flags,
    ImGuiHoveredFlags shared_flags
    );

static ImDrawList* GetViewportBgFgDrawList(
    ImGuiViewportP* viewport,
    size_t drawlist_no,
    const char* drawlist_name
    );

static void TranslateWindow(
    ImGuiWindow* window,
    const ImVec2& delta
    );

static void ScaleWindow(
    ImGuiWindow* window,
    float scale
    );

static bool IsWindowActiveAndVisible(ImGuiWindow* window);
static void SetupDrawListSharedData();

static int IMGUI_CDECL ChildWindowComparer(
    const void* lhs,
    const void* rhs
    );

static void AddWindowToDrawData(
    ImGuiWindow* window,
    int layer
    );

static int GetWindowDisplayLayer(ImGuiWindow* window);
static void AddRootWindowToDrawData(ImGuiWindow* window);
static void FlattenDrawDataIntoSingleLayer(ImDrawDataBuilder* builder);
static void InitViewportDrawData(ImGuiViewportP* viewport);
static ImGuiWindow* FindFrontMostVisibleChildWindow(ImGuiWindow* window);

static void SetWindowConditionAllowFlags(
    ImGuiWindow* window,
    ImGuiCond flags,
    bool enabled
    );

static void ApplyWindowSettings(
    ImGuiWindow* window,
    ImGuiWindowSettings* settings
    );

static void InitOrLoadWindowSettings(
    ImGuiWindow* window,
    ImGuiWindowSettings* settings
    );

static ImGuiWindow* GetWindowForTitleDisplay(ImGuiWindow* window);
static ImGuiWindow* GetWindowForTitleAndMenuHeight(ImGuiWindow* window);
static ImVec2 CalcWindowMinSize(ImGuiWindow* window);

static ImVec2 CalcWindowSizeAfterConstraint(
    ImGuiWindow* window,
    const ImVec2& size_desired
    );

static void CalcWindowContentSizes(
    ImGuiWindow* window,
    ImVec2* content_size_current,
    ImVec2* content_size_ideal
    );

static ImVec2 CalcWindowAutoFitSize(
    ImGuiWindow* window,
    const ImVec2& size_contents,
    int axis_mask
    );

static ImGuiCol GetWindowBgColorIdx(ImGuiWindow* window);

static void CalcResizePosSizeFromAnyCorner(
    ImGuiWindow* window,
    const ImVec2& corner_target_arg,
    const ImVec2& corner_norm,
    ImVec2* out_pos,
    ImVec2* out_size
    );

static ImRect GetResizeBorderRect(
    ImGuiWindow* window,
    int border_n,
    float perp_padding,
    float thickness
    );

static void ClampWindowPos(
    ImGuiWindow* window,
    const ImRect& visibility_rect
    );

static void RenderWindowOuterSingleBorder(
    ImGuiWindow* window,
    int border_n,
    ImU32 border_col,
    float border_size
    );

static void SetWindowActiveForSkipRefresh(ImGuiWindow* window);

static ImGuiWindow* GetCombinedRootWindow(
    ImGuiWindow* window,
    bool popup_hierarchy,
    bool dock_hierarchy
    );

static IM_MSVC_RUNTIME_CHECKS_RESTORE ImGuiKeyChord GetModForLRModKey(ImGuiKey key);
IM_STATIC_ASSERT(ImGuiKey_NamedKey_COUNT = =IM_COUNTOF(GKeyNames));
static ImGuiID GetRoutingIdFromOwnerId(ImGuiID owner_id);

static int CalcRoutingScore(
    ImGuiID focus_scope_id,
    ImGuiID owner_id,
    ImGuiInputFlags flags
    );

static bool IsKeyChordPotentiallyCharInput(ImGuiKeyChord key_chord);

static void UpdateAliasKey(
    ImGuiKey key,
    bool v,
    float analog_value
    );

static ImGuiKeyChord GetMergedModsFromKeys();

static void LockWheelingWindow(
    ImGuiWindow* window,
    float wheel_amount
    );

static ImGuiWindow* FindBestWheelingWindow(const ImVec2& wheel);
static const char* GetInputSourceName(ImGuiInputSource source);
static const char* GetMouseSourceName(ImGuiMouseSource source);

static void DebugPrintInputEvent(
    const char* prefix,
    const ImGuiInputEvent* e
    );

static float CalcScrollEdgeSnap(
    float target,
    float snap_min,
    float snap_max,
    float snap_threshold,
    float center_ratio
    );

static ImGuiDir ImGetDirQuadrantFromDelta(
    float dx,
    float dy
    );

static float NavScoreItemDistInterval(
    float cand_min,
    float cand_max,
    float curr_min,
    float curr_max
    );

static void NavBiasScoringRect(
    ImRect& r,
    ImVec2& preferred_pos_rel,
    ImGuiDir move_dir,
    ImGuiNavMoveFlags move_flags
    );

static ImGuiWindow* FindWindowNavFocusable(
    int i_start,
    int i_stop,
    int dir
    );

static void NavUpdateWindowingTarget(int focus_change_dir);
static const char* GetFallbackWindowNameForWindowingList(ImGuiWindow* window);

static void LogTextV(
    ImGuiContext& g,
    const char* fmt,
    va_list args
    );

static bool IsViewportAbove(
    ImGuiViewportP* potential_above,
    ImGuiViewportP* potential_below
    );

static int IMGUI_CDECL DockNodeComparerDepthMostFirst(
    const void* lhs,
    const void* rhs
    );

static ImVec2 FixLargeWindowsWhenUndocking(
    const ImVec2& size,
    ImGuiViewport* ref_viewport
    );

static void DockNodeHideWindowDuringHostWindowCreation(ImGuiWindow* window);

static void DockNodeFindInfo(
    ImGuiDockNode* node,
    ImGuiDockNodeTreeInfo* info
    );

static void DockNodeSetupHostWindow(
    ImGuiDockNode* node,
    ImGuiWindow* host_window
    );

static int IMGUI_CDECL TabItemComparerByDockOrder(
    const void* lhs,
    const void* rhs
    );

static bool IsDockNodeTitleBarHighlighted(
    ImGuiDockNode* node,
    ImGuiDockNode* root_node
    );

static bool DockNodeIsDropAllowedOne(
    ImGuiWindow* payload,
    ImGuiWindow* host_window
    );

static void DockNodeTreeUpdateSplitterFindTouchingNode(
    ImGuiDockNode* node,
    ImGuiAxis axis,
    int side,
    ImVector<ImGuiDockNode*>* touching_nodes
    );

static ImGuiDockNode* DockBuilderCopyNodeRec(
    ImGuiDockNode* src_node,
    ImGuiID dst_node_id_if_known,
    ImVector<ImGuiID>* out_node_remap_pairs
    );

static void StoreDockStyleForWindow(ImGuiWindow* window);

static void DockSettingsHandler_DockNodeToSettings(
    ImGuiDockContext* dc,
    ImGuiDockNode* node,
    int depth
    );

static void MetricsHelpMarker(const char* desc);
static void RenderViewportsThumbnails();

static int IMGUI_CDECL ViewportComparerByLastFocusedStampCount(
    const void* lhs,
    const void* rhs
    );

static void DebugFlashStyleColorStop();

static const char* FormatTextureRefForDebugDisplay(
    char* buf,
    int buf_size,
    ImTextureRef tex_ref
    );

static void DebugNodeDockNodeFlags(
    ImGuiDockNodeFlags* p_flags,
    const char* label,
    bool enabled
    );

static int CalcFontGlyphSrcOverlapMask(
    ImFontAtlas* atlas,
    ImFont* font,
    unsigned int codepoint
    );

static void SameLineOrWrap(const ImVec2& size);

static void ShowDebugLogFlag(
    const char* name,
    ImGuiDebugLogFlags flags
    );

static ImGuiID DebugItemPathQuery_UpdateAndGetHookId(
    ImGuiDebugItemPathQuery* query,
    ImGuiID id
    );

static int DebugItemPathQuery_FormatLevelInfo(
    ImGuiDebugItemPathQuery* query,
    int n,
    bool format_for_ui,
    char* buf,
    size_t buf_size
    );

static const char* DebugItemPathQuery_GetResultAsPath(
    ImGuiDebugItemPathQuery* query,
    bool hex_encode_non_ascii_chars
    );

void* operator new (
    size_t,
    ImNewWrapper,
    void* ptr
    );

void operator delete (
    void*,
    ImNewWrapper,
    void*
    );

template <typename T>
void IM_DELETE(T* p);

IM_MSVC_RUNTIME_CHECKS_OFF ImVec2 operator * (
    const ImVec2& lhs,
    const float rhs
    );

ImVec2 operator/ (
    const ImVec2& lhs,
    const float rhs
    );

ImVec2 operator + (
    const ImVec2& lhs,
    const ImVec2& rhs
    );

ImVec2 operator - (
    const ImVec2& lhs,
    const ImVec2& rhs
    );

ImVec2 operator * (
    const ImVec2& lhs,
    const ImVec2& rhs
    );

ImVec2 operator/ (
    const ImVec2& lhs,
    const ImVec2& rhs
    );

ImVec2 operator - (const ImVec2& lhs);

ImVec2& operator *= (
    ImVec2& lhs,
    const float rhs
    );

ImVec2& operator/= (
    ImVec2& lhs,
    const float rhs
    );

ImVec2& operator += (
    ImVec2& lhs,
    const ImVec2& rhs
    );

ImVec2& operator -= (
    ImVec2& lhs,
    const ImVec2& rhs
    );

ImVec2& operator *= (
    ImVec2& lhs,
    const ImVec2& rhs
    );

ImVec2& operator/= (
    ImVec2& lhs,
    const ImVec2& rhs
    );

bool operator == (
    const ImVec2& lhs,
    const ImVec2& rhs
    );

bool operator != (
    const ImVec2& lhs,
    const ImVec2& rhs
    );

ImVec4 operator * (
    const ImVec4& lhs,
    const float rhs
    );

ImVec4 operator/ (
    const ImVec4& lhs,
    const float rhs
    );

ImVec4 operator + (
    const ImVec4& lhs,
    const ImVec4& rhs
    );

ImVec4 operator - (
    const ImVec4& lhs,
    const ImVec4& rhs
    );

ImVec4 operator * (
    const ImVec4& lhs,
    const ImVec4& rhs
    );

ImVec4 operator/ (
    const ImVec4& lhs,
    const ImVec4& rhs
    );

ImVec4 operator - (const ImVec4& lhs);

bool operator == (
    const ImVec4& lhs,
    const ImVec4& rhs
    );

bool operator != (
    const ImVec4& lhs,
    const ImVec4& rhs
    );

static void ShowExampleAppMainMenuBar();
static void ShowExampleAppAssetsBrowser(bool* p_open);
static void ShowExampleAppConsole(bool* p_open);
static void ShowExampleAppCustomRendering(bool* p_open);
static void ShowExampleAppDockSpace(bool* p_open);
static void ShowExampleAppDocuments(bool* p_open);
static void ShowExampleAppLog(bool* p_open);
static void ShowExampleAppLayout(bool* p_open);

static void ShowExampleAppPropertyEditor(
    bool* p_open,
    ImGuiDemoWindowData* demo_data
    );

static void ShowExampleAppSimpleOverlay(bool* p_open);
static void ShowExampleAppAutoResize(bool* p_open);
static void ShowExampleAppConstrainedResize(bool* p_open);
static void ShowExampleAppFullscreen(bool* p_open);
static void ShowExampleAppLongText(bool* p_open);
static void ShowExampleAppWindowTitles(bool* p_open);
static void ShowExampleMenuFile();
static void DemoWindowMenuBar(ImGuiDemoWindowData* demo_data);
static void DemoWindowWidgets(ImGuiDemoWindowData* demo_data);
static void DemoWindowLayout();
static void DemoWindowPopups();
static void DemoWindowTables();
static void DemoWindowColumns();
static void DemoWindowInputs();

static ExampleTreeNode* ExampleTree_CreateNode(
    const char* name,
    int uid,
    ExampleTreeNode* parent
    );

static void ExampleTree_DestroyNode(ExampleTreeNode* node);
static void HelpMarker(const char* desc);
static void ShowDockingDisabledMessage();
static ExampleTreeNode* ExampleTree_CreateDemoTree();
static void DemoWindowWidgetsBasic();
static void DemoWindowWidgetsBullets();
static void DemoWindowWidgetsCollapsingHeaders();
static void DemoWindowWidgetsColorAndPickers();
static void DemoWindowWidgetsComboBoxes();
static void DemoWindowWidgetsDataTypes();
static void DemoWindowWidgetsDisableBlocks(ImGuiDemoWindowData* demo_data);
static void DemoWindowWidgetsDragAndDrop();
static void DemoWindowWidgetsDragsAndSliders();
static void DemoWindowWidgetsFonts();
static void DemoWindowWidgetsImages();
static void DemoWindowWidgetsListBoxes();
static void DemoWindowWidgetsMultiComponents();
static void DemoWindowWidgetsPlotting();
static void DemoWindowWidgetsProgressBars();
static void DemoWindowWidgetsQueryingStatuses();
static void DemoWindowWidgetsSelectables();
static void DemoWindowWidgetsSelectionAndMultiSelect(ImGuiDemoWindowData* demo_data);
static void EditTabBarFittingPolicyFlags(ImGuiTabBarFlags* p_flags);
static void DemoWindowWidgetsTabs();
static void DemoWindowWidgetsText();
static void DemoWindowWidgetsTextFilter();
static void DemoWindowWidgetsTextInput();
static void DemoWindowWidgetsTooltips();
static void DemoWindowWidgetsTreeNodes();
static void DemoWindowWidgetsVerticalSliders();
static void PushStyleCompact();
static void PopStyleCompact();
static void EditTableSizingFlags(ImGuiTableFlags* p_flags);
static void EditTableColumnsFlags(ImGuiTableColumnFlags* p_flags);
static void ShowTableColumnsStatusFlags(ImGuiTableColumnFlags flags);
static const char* GetTreeLinesFlagsName(ImGuiTreeNodeFlags flags);

static void PathConcaveShape(
    ImDrawList* draw_list,
    float x,
    float y,
    float sz
    );

static void ShowExampleAppDockSpaceAdvanced(
    ImGuiDemoDockspaceArgs* args,
    bool* p_open
    );

static void ShowExampleAppDockSpaceBasic(ImGuiDockNodeFlags flags);

ImVec2 ImBezierCubicCalc(
    const ImVec2& p1,
    const ImVec2& p2,
    const ImVec2& p3,
    const ImVec2& p4,
    float t
    );

ImVec2 ImBezierQuadraticCalc(
    const ImVec2& p1,
    const ImVec2& p2,
    const ImVec2& p3,
    float t
    );

static void PathBezierCubicCurveToCasteljau(
    ImVector<ImVec2>* path,
    float x1,
    float y1,
    float x2,
    float y2,
    float x3,
    float y3,
    float x4,
    float y4,
    float tess_tol,
    int level
    );

static void PathBezierQuadraticCurveToCasteljau(
    ImVector<ImVec2>* path,
    float x1,
    float y1,
    float x2,
    float y2,
    float x3,
    float y3,
    float tess_tol,
    int level
    );

static ImDrawFlags FixRectCornerFlags(ImDrawFlags flags);
int ImTextureDataGetFormatBytesPerPixel(ImTextureFormat format);
const char* ImTextureDataGetStatusName(ImTextureStatus status);
const char* ImTextureDataGetFormatName(ImTextureFormat format);
static void ImFontAtlasBuildUpdateRendererHasTexturesFromContext(ImFontAtlas* atlas);

void ImFontAtlasUpdateNewFrame(
    ImFontAtlas* atlas,
    int frame_count,
    bool renderer_has_textures
    );

void ImFontAtlasTextureBlockConvert(
    const unsigned char* src_pixels,
    ImTextureFormat src_fmt,
    int src_pitch,
    unsigned char* dst_pixels,
    ImTextureFormat dst_fmt,
    int dst_pitch,
    int w,
    int h
    );

void ImFontAtlasTextureBlockPostProcess(ImFontAtlasPostProcessData* data);

void ImFontAtlasTextureBlockPostProcessMultiply(
    ImFontAtlasPostProcessData* data,
    float multiply_factor
    );

void ImFontAtlasTextureBlockFill(
    ImTextureData* dst_tex,
    int dst_x,
    int dst_y,
    int w,
    int h,
    ImU32 col
    );

void ImFontAtlasTextureBlockCopy(
    ImTextureData* src_tex,
    int src_x,
    int src_y,
    ImTextureData* dst_tex,
    int dst_x,
    int dst_y,
    int w,
    int h
    );

void ImFontAtlasTextureBlockQueueUpload(
    ImFontAtlas* atlas,
    ImTextureData* tex,
    int x,
    int y,
    int w,
    int h
    );

static void GetTexDataAsFormat(
    ImFontAtlas* atlas,
    ImTextureFormat format,
    unsigned char** out_pixels,
    int* out_width,
    int* out_height,
    int* out_bytes_per_pixel
    );

static unsigned int stb_decompress_length(const unsigned char* input);

static unsigned int stb_decompress(
    unsigned char* output,
    const unsigned char* input,
    unsigned int length
    );

static unsigned int Decode85Byte(char c);

static void Decode85(
    const unsigned char* src,
    unsigned char* dst
    );

static const char* GetDefaultCompressedFontDataProggyClean(int* out_size);
static const char* GetDefaultCompressedFontDataProggyForever(int* out_size);
static float GetExpectedContextFontSize(ImGuiContext* ctx);

void ImFontAtlasBuildNotifySetFont(
    ImFontAtlas* atlas,
    ImFont* old_font,
    ImFont* new_font
    );

bool ImFontAtlasGetMouseCursorTexData(
    ImFontAtlas* atlas,
    ImGuiMouseCursor cursor_type,
    ImVec2* out_offset,
    ImVec2* out_size,
    ImVec2 out_uv_border [2],
    ImVec2 out_uv_fill [2]
    );

void ImFontAtlasBuildMain(ImFontAtlas* atlas);

void ImFontAtlasBuildGetOversampleFactors(
    ImFontConfig* src,
    ImFontBaked* baked,
    int* out_oversample_h,
    int* out_oversample_v
    );

void ImFontAtlasBuildSetupFontLoader(
    ImFontAtlas* atlas,
    const ImFontLoader* font_loader
    );

void ImFontAtlasBuildLegacyPreloadAllGlyphRanges(ImFontAtlas* atlas);
void ImFontAtlasBuildUpdatePointers(ImFontAtlas* atlas);

void ImFontAtlasBuildRenderBitmapFromString(
    ImFontAtlas* atlas,
    int x,
    int y,
    int w,
    int h,
    const char* in_str,
    char in_marker_char
    );

static void ImFontAtlasBuildUpdateBasicTexData(ImFontAtlas* atlas);
static void ImFontAtlasBuildUpdateLinesTexData(ImFontAtlas* atlas);

bool ImFontAtlasFontInitOutput(
    ImFontAtlas* atlas,
    ImFont* font
    );

void ImFontAtlasFontDestroyOutput(
    ImFontAtlas* atlas,
    ImFont* font
    );

void ImFontAtlasFontRebuildOutput(
    ImFontAtlas* atlas,
    ImFont* font
    );

bool ImFontAtlasFontSourceInit(
    ImFontAtlas* atlas,
    ImFontConfig* src
    );

void ImFontAtlasFontSourceAddToFont(
    ImFontAtlas* atlas,
    ImFont* font,
    ImFontConfig* src
    );

void ImFontAtlasFontDestroySourceData(
    ImFontAtlas* atlas,
    ImFontConfig* src
    );

static ImFontGlyph* ImFontAtlasBuildSetupFontBakedEllipsis(
    ImFontAtlas* atlas,
    ImFontBaked* baked
    );

static void ImFontAtlasBuildSetupFontBakedFallback(ImFontBaked* baked);

static void ImFontAtlasBuildSetupFontBakedBlanks(
    ImFontAtlas* atlas,
    ImFontBaked* baked
    );

void ImFontAtlasBuildSetupFontSpecialGlyphs(
    ImFontAtlas* atlas,
    ImFont* font,
    ImFontConfig* src
    );

void ImFontAtlasBakedDiscardFontGlyph(
    ImFontAtlas* atlas,
    ImFont* font,
    ImFontBaked* baked,
    ImFontGlyph* glyph
    );

ImFontBaked* ImFontAtlasBakedAdd(
    ImFontAtlas* atlas,
    ImFont* font,
    float font_size,
    float font_rasterizer_density,
    ImGuiID baked_id
    );

ImFontBaked* ImFontAtlasBakedGetClosestMatch(
    ImFontAtlas* atlas,
    ImFont* font,
    float font_size,
    float font_rasterizer_density
    );

void ImFontAtlasBakedDiscard(
    ImFontAtlas* atlas,
    ImFont* font,
    ImFontBaked* baked
    );

void ImFontAtlasFontDiscardBakes(
    ImFontAtlas* atlas,
    ImFont* font,
    int unused_frames
    );

void ImFontAtlasBuildDiscardBakes(
    ImFontAtlas* atlas,
    int unused_frames
    );

void ImFontAtlasAddDrawListSharedData(
    ImFontAtlas* atlas,
    ImDrawListSharedData* data
    );

void ImFontAtlasRemoveDrawListSharedData(
    ImFontAtlas* atlas,
    ImDrawListSharedData* data
    );

void ImFontAtlasUpdateDrawListsTextures(
    ImFontAtlas* atlas,
    ImTextureRef old_tex,
    ImTextureRef new_tex
    );

void ImFontAtlasUpdateDrawListsSharedData(ImFontAtlas* atlas);

static void ImFontAtlasBuildSetTexture(
    ImFontAtlas* atlas,
    ImTextureData* tex
    );

ImTextureData* ImFontAtlasTextureAdd(
    ImFontAtlas* atlas,
    int w,
    int h
    );

void ImFontAtlasTextureRepack(
    ImFontAtlas* atlas,
    int w,
    int h
    );

void ImFontAtlasTextureGrow(
    ImFontAtlas* atlas,
    int old_tex_w,
    int old_tex_h
    );

void ImFontAtlasTextureMakeSpace(ImFontAtlas* atlas);
ImVec2i ImFontAtlasTextureGetSizeEstimate(ImFontAtlas* atlas);
void ImFontAtlasBuildClear(ImFontAtlas* atlas);
void ImFontAtlasTextureCompact(ImFontAtlas* atlas);
void ImFontAtlasBuildInit(ImFontAtlas* atlas);
void ImFontAtlasBuildDestroy(ImFontAtlas* atlas);
void ImFontAtlasPackInit(ImFontAtlas* atlas);

static ImFontAtlasRectId ImFontAtlasPackAllocRectEntry(
    ImFontAtlas* atlas,
    int rect_idx
    );

static ImFontAtlasRectId ImFontAtlasPackReuseRectEntry(
    ImFontAtlas* atlas,
    ImFontAtlasRectEntry* index_entry
    );

void ImFontAtlasPackDiscardRect(
    ImFontAtlas* atlas,
    ImFontAtlasRectId id
    );

ImFontAtlasRectId ImFontAtlasPackAddRect(
    ImFontAtlas* atlas,
    int w,
    int h,
    ImFontAtlasRectEntry* overwrite_entry
    );

ImTextureRect* ImFontAtlasPackGetRect(
    ImFontAtlas* atlas,
    ImFontAtlasRectId id
    );

ImTextureRect* ImFontAtlasPackGetRectSafe(
    ImFontAtlas* atlas,
    ImFontAtlasRectId id
    );

static bool ImFontAtlasBuildAcceptCodepointForSource(
    ImFontConfig* src,
    ImWchar codepoint
    );

static void ImFontBaked_BuildGrowIndex(
    ImFontBaked* baked,
    int new_size
    );

static void ImFontAtlas_FontHookRemapCodepoint(
    ImFontAtlas* atlas,
    ImFont* font,
    ImWchar* c
    );

static ImFontGlyph* ImFontBaked_BuildLoadGlyph(
    ImFontBaked* baked,
    ImWchar codepoint,
    float* only_load_advance_x
    );

static float ImFontBaked_BuildLoadGlyphAdvanceX(
    ImFontBaked* baked,
    ImWchar codepoint
    );

static IM_MSVC_RUNTIME_CHECKS_OFF float BuildLoadGlyphGetAdvanceOrFallback(
    ImFontBaked* baked,
    unsigned int codepoint
    );

IM_MSVC_RUNTIME_CHECKS_RESTORE void ImFontAtlasDebugLogTextureRequests(ImFontAtlas* atlas);

static bool ImGui_ImplStbTrueType_FontSrcInit(
    ImFontAtlas* atlas,
    ImFontConfig* src
    );

static void ImGui_ImplStbTrueType_FontSrcDestroy(
    ImFontAtlas* atlas,
    ImFontConfig* src
    );

static bool ImGui_ImplStbTrueType_FontSrcContainsGlyph(
    ImFontAtlas* atlas,
    ImFontConfig* src,
    ImWchar codepoint
    );

static bool ImGui_ImplStbTrueType_FontBakedInit(
    ImFontAtlas* atlas,
    ImFontConfig* src,
    ImFontBaked* baked,
    void*
    );

static bool ImGui_ImplStbTrueType_FontBakedLoadGlyph(
    ImFontAtlas* atlas,
    ImFontConfig* src,
    ImFontBaked* baked,
    void*,
    ImWchar codepoint,
    ImFontGlyph* out_glyph,
    float* out_advance_x
    );

const ImFontLoader* ImFontAtlasGetFontLoaderForStbTruetype();

static void UnpackAccumulativeOffsetsIntoRanges(
    int base_codepoint,
    const short* accumulative_offsets,
    int accumulative_offsets_count,
    ImWchar* out_ranges
    );

ImFontGlyph* ImFontAtlasBakedAddFontGlyph(
    ImFontAtlas* atlas,
    ImFontBaked* baked,
    ImFontConfig* src,
    const ImFontGlyph* in_glyph
    );

void ImFontAtlasBakedAddFontGlyphAdvancedX(
    ImFontAtlas* atlas,
    ImFontBaked* baked,
    ImFontConfig* src,
    ImWchar codepoint,
    float advance_x
    );

void ImFontAtlasBakedSetFontGlyphBitmap(
    ImFontAtlas* atlas,
    ImFontBaked* baked,
    ImFontConfig* src,
    ImFontGlyph* glyph,
    ImTextureRect* r,
    const unsigned char* src_pixels,
    ImTextureFormat src_fmt,
    int src_pitch
    );

IM_MSVC_RUNTIME_CHECKS_RESTORE ImGuiID ImFontAtlasBakedGetId(
    ImGuiID font_id,
    float baked_size,
    float rasterizer_density
    );

ImFontBaked* ImFontAtlasBakedGetOrAdd(
    ImFontAtlas* atlas,
    ImFont* font,
    float font_size,
    float font_rasterizer_density
    );

const char* ImTextCalcWordWrapNextLineStart(
    const char* text,
    const char* text_end,
    ImDrawTextFlags flags
    );

void ImTextClassifierClear(
    ImU32* bits,
    unsigned int codepoint_min,
    unsigned int codepoint_end,
    ImWcharClass char_class
    );

void ImTextClassifierSetCharClass(
    ImU32* bits,
    unsigned int codepoint_min,
    unsigned int codepoint_end,
    ImWcharClass char_class,
    unsigned int c
    );

void ImTextClassifierSetCharClassFromStr(
    ImU32* bits,
    unsigned int codepoint_min,
    unsigned int codepoint_end,
    ImWcharClass char_class,
    const char* s
    );

void ImTextInitClassifiers();

const char* ImFontCalcWordWrapPositionEx(
    ImFont* font,
    float size,
    const char* text,
    const char* text_end,
    float wrap_width,
    ImDrawTextFlags flags
    );

ImVec2 ImFontCalcTextSizeEx(
    ImFont* font,
    float size,
    float max_width,
    float wrap_width,
    const char* text_begin,
    const char* text_end_display,
    const char* text_end,
    const char** out_remaining,
    ImVec2* out_offset,
    ImDrawTextFlags flags
    );

static float ImAcos01(float x);

static void stb__match(
    const unsigned char* data,
    unsigned int length
    );

static void stb__lit(
    const unsigned char* data,
    unsigned int length
    );

static const unsigned char* stb_decompress_token(const unsigned char* i);

static unsigned int stb_adler32(
    unsigned int adler32,
    unsigned char* buffer,
    unsigned int buflen
    );

IMGUI_API ImGuiID ImHashData(
    const void* data,
    size_t data_size,
    ImGuiID seed = 0
    );

IMGUI_API ImGuiID ImHashStr(
    const char* data,
    size_t data_size = 0,
    ImGuiID seed = 0
    );

IMGUI_API const char* ImHashSkipUncontributingPrefix(const char* label);

void ImQsort(
    void* base,
    size_t count,
    size_t size_of_element,
    int(IMGUI_CDECL*compare_func)(void const*, void const*)
    );

IMGUI_API ImU32 ImAlphaBlendColors(
    ImU32 col_a,
    ImU32 col_b
    );

bool ImIsPowerOfTwo(int v);
bool ImIsPowerOfTwo(ImU64 v);
int ImUpperPowerOfTwo(int v);
unsigned int ImCountSetBits(unsigned int v);

IMGUI_API int ImStricmp(
    const char* str1,
    const char* str2
    );

IMGUI_API int ImStrnicmp(
    const char* str1,
    const char* str2,
    size_t count
    );

IMGUI_API void ImStrncpy(
    char* dst,
    const char* src,
    size_t count
    );

IMGUI_API char* ImStrdup(const char* str);

IMGUI_API void* ImMemdup(
    const void* src,
    size_t size
    );

IMGUI_API char* ImStrdupcpy(
    char* dst,
    size_t* p_dst_size,
    const char* str
    );

IMGUI_API const char* ImStrchrRange(
    const char* str_begin,
    const char* str_end,
    char c
    );

IMGUI_API const char* ImStreolRange(
    const char* str,
    const char* str_end
    );

IMGUI_API const char* ImStristr(
    const char* haystack,
    const char* haystack_end,
    const char* needle,
    const char* needle_end
    );

IMGUI_API void ImStrTrimBlanks(char* str);
IMGUI_API const char* ImStrSkipBlank(const char* str);
IMGUI_API int ImStrlenW(const ImWchar* str);

IMGUI_API const char* ImStrbol(
    const char* buf_mid_line,
    const char* buf_begin
    );

IM_MSVC_RUNTIME_CHECKS_OFF char ImToUpper(char c);
bool ImCharIsBlankA(char c);
bool ImCharIsBlankW(unsigned int c);
bool ImCharIsXdigitA(char c);

IM_MSVC_RUNTIME_CHECKS_RESTORE IMGUI_API int ImFormatString(
    char* buf,
    size_t buf_size,
    const char* fmt,
    ...
    );

IMGUI_API int ImFormatStringV(
    char* buf,
    size_t buf_size,
    const char* fmt,
    va_list args
    );

IMGUI_API void ImFormatStringToTempBuffer(
    const char** out_buf,
    const char** out_buf_end,
    const char* fmt,
    ...
    );

IMGUI_API void ImFormatStringToTempBufferV(
    const char** out_buf,
    const char** out_buf_end,
    const char* fmt,
    va_list args
    );

IMGUI_API const char* ImParseFormatFindStart(const char* format);
IMGUI_API const char* ImParseFormatFindEnd(const char* format);

IMGUI_API const char* ImParseFormatTrimDecorations(
    const char* format,
    char* buf,
    size_t buf_size
    );

IMGUI_API void ImParseFormatSanitizeForPrinting(
    const char* fmt_in,
    char* fmt_out,
    size_t fmt_out_size
    );

IMGUI_API const char* ImParseFormatSanitizeForScanning(
    const char* fmt_in,
    char* fmt_out,
    size_t fmt_out_size
    );

IMGUI_API int ImParseFormatPrecision(
    const char* format,
    int default_value
    );

IMGUI_API int ImTextCharToUtf8(
    char out_buf [5],
    unsigned int c
    );

IMGUI_API int ImTextStrToUtf8(
    char* out_buf,
    int out_buf_size,
    const ImWchar* in_text,
    const ImWchar* in_text_end
    );

IMGUI_API int ImTextCharFromUtf8(
    unsigned int* out_char,
    const char* in_text,
    const char* in_text_end
    );

IMGUI_API int ImTextStrFromUtf8(
    ImWchar* out_buf,
    int out_buf_size,
    const char* in_text,
    const char* in_text_end,
    const char** in_remaining = NULL
    );

IMGUI_API int ImTextCountCharsFromUtf8(
    const char* in_text,
    const char* in_text_end
    );

IMGUI_API int ImTextCountUtf8BytesFromChar(
    const char* in_text,
    const char* in_text_end
    );

IMGUI_API int ImTextCountUtf8BytesFromStr(
    const ImWchar* in_text,
    const ImWchar* in_text_end
    );

IMGUI_API const char* ImTextFindPreviousUtf8Codepoint(
    const char* in_text_start,
    const char* in_p
    );

IMGUI_API const char* ImTextFindValidUtf8CodepointEnd(
    const char* in_text_start,
    const char* in_text_end,
    const char* in_p
    );

IMGUI_API int ImTextCountLines(
    const char* in_text,
    const char* in_text_end
    );

IMGUI_API ImVec2 ImFontCalcTextSizeEx(
    ImFont* font,
    float size,
    float max_width,
    float wrap_width,
    const char* text_begin,
    const char* text_end_display,
    const char* text_end,
    const char** out_remaining,
    ImVec2* out_offset,
    ImDrawTextFlags flags
    );

IMGUI_API const char* ImFontCalcWordWrapPositionEx(
    ImFont* font,
    float size,
    const char* text,
    const char* text_end,
    float wrap_width,
    ImDrawTextFlags flags = 0
    );

IMGUI_API const char* ImTextCalcWordWrapNextLineStart(
    const char* text,
    const char* text_end,
    ImDrawTextFlags flags = 0
    );

IMGUI_API void ImTextInitClassifiers();

IMGUI_API void ImTextClassifierClear(
    ImU32* bits,
    unsigned int codepoint_min,
    unsigned int codepoint_end,
    ImWcharClass char_class
    );

IMGUI_API void ImTextClassifierSetCharClass(
    ImU32* bits,
    unsigned int codepoint_min,
    unsigned int codepoint_end,
    ImWcharClass char_class,
    unsigned int c
    );

IMGUI_API void ImTextClassifierSetCharClassFromStr(
    ImU32* bits,
    unsigned int codepoint_min,
    unsigned int codepoint_end,
    ImWcharClass char_class,
    const char* s
    );

IMGUI_API ImFileHandle ImFileOpen(
    const char* filename,
    const char* mode
    );

IMGUI_API bool ImFileClose(ImFileHandle file);
IMGUI_API ImU64 ImFileGetSize(ImFileHandle file);

IMGUI_API ImU64 ImFileRead(
    void* data,
    ImU64 size,
    ImU64 count,
    ImFileHandle file
    );

IMGUI_API ImU64 ImFileWrite(
    const void* data,
    ImU64 size,
    ImU64 count,
    ImFileHandle file
    );

IMGUI_API void* ImFileLoadToMemory(
    const char* filename,
    const char* mode,
    size_t* out_file_size = NULL,
    int padding_bytes = 0
    );

float ImPow(
    float x,
    float y
    );

double ImPow(
    double x,
    double y
    );

float ImLog(float x);
double ImLog(double x);
int ImAbs(int x);
float ImAbs(float x);
double ImAbs(double x);
float ImSign(float x);
double ImSign(double x);
float ImRsqrt(float x);
double ImRsqrt(double x);

template <typename T>
T ImMin(
    T lhs,
    T rhs
    );

template <typename T>
T ImMax(
    T lhs,
    T rhs
    );

template <typename T>
T ImClamp(
    T v,
    T mn,
    T mx
    );

template <typename T>
T ImLerp(
    T a,
    T b,
    float t
    );

template <typename T>
void ImSwap(
    T& a,
    T& b
    );

template <typename T>
T ImAddClampOverflow(
    T a,
    T b,
    T mn,
    T mx
    );

template <typename T>
T ImSubClampOverflow(
    T a,
    T b,
    T mn,
    T mx
    );

ImVec2 ImMin(
    const ImVec2& lhs,
    const ImVec2& rhs
    );

ImVec2 ImMax(
    const ImVec2& lhs,
    const ImVec2& rhs
    );

ImVec2 ImClamp(
    const ImVec2& v,
    const ImVec2& mn,
    const ImVec2& mx
    );

ImVec2 ImLerp(
    const ImVec2& a,
    const ImVec2& b,
    float t
    );

ImVec2 ImLerp(
    const ImVec2& a,
    const ImVec2& b,
    const ImVec2& t
    );

ImVec4 ImLerp(
    const ImVec4& a,
    const ImVec4& b,
    float t
    );

float ImSaturate(float f);
float ImLengthSqr(const ImVec2& lhs);
float ImLengthSqr(const ImVec4& lhs);

float ImInvLength(
    const ImVec2& lhs,
    float fail_value
    );

float ImTrunc(float f);
ImVec2 ImTrunc(const ImVec2& v);
float ImFloor(float f);
ImVec2 ImFloor(const ImVec2& v);
float ImTrunc64(float f);
float ImRound64(float f);

int ImModPositive(
    int a,
    int b
    );

float ImDot(
    const ImVec2& a,
    const ImVec2& b
    );

ImVec2 ImRotate(
    const ImVec2& v,
    float cos_a,
    float sin_a
    );

float ImLinearSweep(
    float current,
    float target,
    float speed
    );

float ImLinearRemapClamp(
    float s0,
    float s1,
    float d0,
    float d1,
    float x
    );

ImVec2 ImMul(
    const ImVec2& lhs,
    const ImVec2& rhs
    );

bool ImIsFloatAboveGuaranteedIntegerPrecision(float f);

float ImExponentialMovingAverage(
    float avg,
    float sample,
    int n
    );

IM_MSVC_RUNTIME_CHECKS_RESTORE IMGUI_API ImVec2 ImBezierCubicCalc(
    const ImVec2& p1,
    const ImVec2& p2,
    const ImVec2& p3,
    const ImVec2& p4,
    float t
    );

IMGUI_API ImVec2 ImBezierCubicClosestPoint(
    const ImVec2& p1,
    const ImVec2& p2,
    const ImVec2& p3,
    const ImVec2& p4,
    const ImVec2& p,
    int num_segments
    );

IMGUI_API ImVec2 ImBezierCubicClosestPointCasteljau(
    const ImVec2& p1,
    const ImVec2& p2,
    const ImVec2& p3,
    const ImVec2& p4,
    const ImVec2& p,
    float tess_tol
    );

IMGUI_API ImVec2 ImBezierQuadraticCalc(
    const ImVec2& p1,
    const ImVec2& p2,
    const ImVec2& p3,
    float t
    );

IMGUI_API ImVec2 ImLineClosestPoint(
    const ImVec2& a,
    const ImVec2& b,
    const ImVec2& p
    );

IMGUI_API bool ImTriangleContainsPoint(
    const ImVec2& a,
    const ImVec2& b,
    const ImVec2& c,
    const ImVec2& p
    );

IMGUI_API ImVec2 ImTriangleClosestPoint(
    const ImVec2& a,
    const ImVec2& b,
    const ImVec2& c,
    const ImVec2& p
    );

IMGUI_API void ImTriangleBarycentricCoords(
    const ImVec2& a,
    const ImVec2& b,
    const ImVec2& c,
    const ImVec2& p,
    float& out_u,
    float& out_v,
    float& out_w
    );

float ImTriangleArea(
    const ImVec2& a,
    const ImVec2& b,
    const ImVec2& c
    );

bool ImTriangleIsClockwise(
    const ImVec2& a,
    const ImVec2& b,
    const ImVec2& c
    );

size_t ImBitArrayGetStorageSizeInBytes(int bitcount);

void ImBitArrayClearAllBits(
    ImU32* arr,
    int bitcount
    );

bool ImBitArrayTestBit(
    const ImU32* arr,
    int n
    );

void ImBitArrayClearBit(
    ImU32* arr,
    int n
    );

void ImBitArraySetBit(
    ImU32* arr,
    int n
    );

void ImBitArraySetBitRange(
    ImU32* arr,
    int n,
    int n2
    );

IMGUI_API ImGuiStoragePair* ImLowerBound(
    ImGuiStoragePair* in_begin,
    ImGuiStoragePair* in_end,
    ImGuiID key
    );

IMGUI_API const ImFontLoader* ImFontAtlasGetFontLoaderForStbTruetype();

bool operator == (
    const ImTextureRef& lhs,
    const ImTextureRef& rhs
    );

bool operator != (
    const ImTextureRef& lhs,
    const ImTextureRef& rhs
    );

int ImFontAtlasRectId_GetIndex(ImFontAtlasRectId id);
unsigned int ImFontAtlasRectId_GetGeneration(ImFontAtlasRectId id);

ImFontAtlasRectId ImFontAtlasRectId_Make(
    int index_idx,
    int gen_idx
    );

IMGUI_API void ImFontAtlasBuildInit(ImFontAtlas* atlas);
IMGUI_API void ImFontAtlasBuildDestroy(ImFontAtlas* atlas);
IMGUI_API void ImFontAtlasBuildMain(ImFontAtlas* atlas);

IMGUI_API void ImFontAtlasBuildSetupFontLoader(
    ImFontAtlas* atlas,
    const ImFontLoader* font_loader
    );

IMGUI_API void ImFontAtlasBuildNotifySetFont(
    ImFontAtlas* atlas,
    ImFont* old_font,
    ImFont* new_font
    );

IMGUI_API void ImFontAtlasBuildUpdatePointers(ImFontAtlas* atlas);

IMGUI_API void ImFontAtlasBuildRenderBitmapFromString(
    ImFontAtlas* atlas,
    int x,
    int y,
    int w,
    int h,
    const char* in_str,
    char in_marker_char
    );

IMGUI_API void ImFontAtlasBuildClear(ImFontAtlas* atlas);

IMGUI_API ImTextureData* ImFontAtlasTextureAdd(
    ImFontAtlas* atlas,
    int w,
    int h
    );

IMGUI_API void ImFontAtlasTextureMakeSpace(ImFontAtlas* atlas);

IMGUI_API void ImFontAtlasTextureRepack(
    ImFontAtlas* atlas,
    int w,
    int h
    );

IMGUI_API void ImFontAtlasTextureGrow(
    ImFontAtlas* atlas,
    int old_w = -1,
    int old_h = -1
    );

IMGUI_API void ImFontAtlasTextureCompact(ImFontAtlas* atlas);
IMGUI_API ImVec2i ImFontAtlasTextureGetSizeEstimate(ImFontAtlas* atlas);

IMGUI_API void ImFontAtlasBuildSetupFontSpecialGlyphs(
    ImFontAtlas* atlas,
    ImFont* font,
    ImFontConfig* src
    );

IMGUI_API void ImFontAtlasBuildLegacyPreloadAllGlyphRanges(ImFontAtlas* atlas);

IMGUI_API void ImFontAtlasBuildGetOversampleFactors(
    ImFontConfig* src,
    ImFontBaked* baked,
    int* out_oversample_h,
    int* out_oversample_v
    );

IMGUI_API void ImFontAtlasBuildDiscardBakes(
    ImFontAtlas* atlas,
    int unused_frames
    );

IMGUI_API bool ImFontAtlasFontSourceInit(
    ImFontAtlas* atlas,
    ImFontConfig* src
    );

IMGUI_API void ImFontAtlasFontSourceAddToFont(
    ImFontAtlas* atlas,
    ImFont* font,
    ImFontConfig* src
    );

IMGUI_API void ImFontAtlasFontDestroySourceData(
    ImFontAtlas* atlas,
    ImFontConfig* src
    );

IMGUI_API bool ImFontAtlasFontInitOutput(
    ImFontAtlas* atlas,
    ImFont* font
    );

IMGUI_API void ImFontAtlasFontDestroyOutput(
    ImFontAtlas* atlas,
    ImFont* font
    );

IMGUI_API void ImFontAtlasFontRebuildOutput(
    ImFontAtlas* atlas,
    ImFont* font
    );

IMGUI_API void ImFontAtlasFontDiscardBakes(
    ImFontAtlas* atlas,
    ImFont* font,
    int unused_frames
    );

IMGUI_API ImGuiID ImFontAtlasBakedGetId(
    ImGuiID font_id,
    float baked_size,
    float rasterizer_density
    );

IMGUI_API ImFontBaked* ImFontAtlasBakedGetOrAdd(
    ImFontAtlas* atlas,
    ImFont* font,
    float font_size,
    float font_rasterizer_density
    );

IMGUI_API ImFontBaked* ImFontAtlasBakedGetClosestMatch(
    ImFontAtlas* atlas,
    ImFont* font,
    float font_size,
    float font_rasterizer_density
    );

IMGUI_API ImFontBaked* ImFontAtlasBakedAdd(
    ImFontAtlas* atlas,
    ImFont* font,
    float font_size,
    float font_rasterizer_density,
    ImGuiID baked_id
    );

IMGUI_API void ImFontAtlasBakedDiscard(
    ImFontAtlas* atlas,
    ImFont* font,
    ImFontBaked* baked
    );

IMGUI_API ImFontGlyph* ImFontAtlasBakedAddFontGlyph(
    ImFontAtlas* atlas,
    ImFontBaked* baked,
    ImFontConfig* src,
    const ImFontGlyph* in_glyph
    );

IMGUI_API void ImFontAtlasBakedAddFontGlyphAdvancedX(
    ImFontAtlas* atlas,
    ImFontBaked* baked,
    ImFontConfig* src,
    ImWchar codepoint,
    float advance_x
    );

IMGUI_API void ImFontAtlasBakedDiscardFontGlyph(
    ImFontAtlas* atlas,
    ImFont* font,
    ImFontBaked* baked,
    ImFontGlyph* glyph
    );

IMGUI_API void ImFontAtlasBakedSetFontGlyphBitmap(
    ImFontAtlas* atlas,
    ImFontBaked* baked,
    ImFontConfig* src,
    ImFontGlyph* glyph,
    ImTextureRect* r,
    const unsigned char* src_pixels,
    ImTextureFormat src_fmt,
    int src_pitch
    );

IMGUI_API void ImFontAtlasPackInit(ImFontAtlas* atlas);

IMGUI_API ImFontAtlasRectId ImFontAtlasPackAddRect(
    ImFontAtlas* atlas,
    int w,
    int h,
    ImFontAtlasRectEntry* overwrite_entry = NULL
    );

IMGUI_API ImTextureRect* ImFontAtlasPackGetRect(
    ImFontAtlas* atlas,
    ImFontAtlasRectId id
    );

IMGUI_API ImTextureRect* ImFontAtlasPackGetRectSafe(
    ImFontAtlas* atlas,
    ImFontAtlasRectId id
    );

IMGUI_API void ImFontAtlasPackDiscardRect(
    ImFontAtlas* atlas,
    ImFontAtlasRectId id
    );

IMGUI_API void ImFontAtlasUpdateNewFrame(
    ImFontAtlas* atlas,
    int frame_count,
    bool renderer_has_textures
    );

IMGUI_API void ImFontAtlasAddDrawListSharedData(
    ImFontAtlas* atlas,
    ImDrawListSharedData* data
    );

IMGUI_API void ImFontAtlasRemoveDrawListSharedData(
    ImFontAtlas* atlas,
    ImDrawListSharedData* data
    );

IMGUI_API void ImFontAtlasUpdateDrawListsTextures(
    ImFontAtlas* atlas,
    ImTextureRef old_tex,
    ImTextureRef new_tex
    );

IMGUI_API void ImFontAtlasUpdateDrawListsSharedData(ImFontAtlas* atlas);

IMGUI_API void ImFontAtlasTextureBlockConvert(
    const unsigned char* src_pixels,
    ImTextureFormat src_fmt,
    int src_pitch,
    unsigned char* dst_pixels,
    ImTextureFormat dst_fmt,
    int dst_pitch,
    int w,
    int h
    );

IMGUI_API void ImFontAtlasTextureBlockPostProcess(ImFontAtlasPostProcessData* data);

IMGUI_API void ImFontAtlasTextureBlockPostProcessMultiply(
    ImFontAtlasPostProcessData* data,
    float multiply_factor
    );

IMGUI_API void ImFontAtlasTextureBlockFill(
    ImTextureData* dst_tex,
    int dst_x,
    int dst_y,
    int w,
    int h,
    ImU32 col
    );

IMGUI_API void ImFontAtlasTextureBlockCopy(
    ImTextureData* src_tex,
    int src_x,
    int src_y,
    ImTextureData* dst_tex,
    int dst_x,
    int dst_y,
    int w,
    int h
    );

IMGUI_API void ImFontAtlasTextureBlockQueueUpload(
    ImFontAtlas* atlas,
    ImTextureData* tex,
    int x,
    int y,
    int w,
    int h
    );

IMGUI_API int ImTextureDataGetFormatBytesPerPixel(ImTextureFormat format);
IMGUI_API const char* ImTextureDataGetStatusName(ImTextureStatus status);
IMGUI_API const char* ImTextureDataGetFormatName(ImTextureFormat format);
IMGUI_API void ImFontAtlasDebugLogTextureRequests(ImFontAtlas* atlas);

IMGUI_API bool ImFontAtlasGetMouseCursorTexData(
    ImFontAtlas* atlas,
    ImGuiMouseCursor cursor_type,
    ImVec2* out_offset,
    ImVec2* out_size,
    ImVec2 out_uv_border [2],
    ImVec2 out_uv_fill [2]
    );

ImGuiTableFlags TableFixFlags(
    ImGuiTableFlags flags,
    ImGuiWindow* outer_window
    );

static void TableSetupColumnFlags(
    ImGuiTable* table,
    ImGuiTableColumn* column,
    ImGuiTableColumnFlags flags_in
    );

static void TableInitColumnDefaults(
    ImGuiTable* table,
    ImGuiTableColumn* column,
    ImGuiTableColumnFlags init_mask
    );

static ImU32 TableGetColumnBorderCol(
    ImGuiTable* table,
    int order_n,
    int column_n
    );

static ImGuiSortDirection TableGetColumnAvailSortDirection(
    ImGuiTableColumn* column,
    int n
    );

IM_STATIC_ASSERT(ImGuiSortDirection_None = =0&&ImGuiSortDirection_Ascending==1&&ImGuiSortDirection_Descending==2);

static void TableSettingsInit(
    ImGuiTableSettings* settings,
    ImGuiID id,
    int columns_count,
    int columns_count_max
    );

static size_t TableSettingsCalcChunkSize(int columns_count);

static int IMGUI_CDECL TableFixDisplayOrderComparer(
    const void* lhs,
    const void* rhs
    );

static void TableSettingsHandler_ClearAll(
    ImGuiContext* ctx,
    ImGuiSettingsHandler*
    );

static void TableSettingsHandler_ApplyAll(
    ImGuiContext* ctx,
    ImGuiSettingsHandler*
    );

static void* TableSettingsHandler_ReadOpen(
    ImGuiContext*,
    ImGuiSettingsHandler*,
    const char* name
    );

static void TableSettingsHandler_ReadLine(
    ImGuiContext*,
    ImGuiSettingsHandler*,
    void* entry,
    const char* line
    );

static void TableSettingsHandler_WriteAll(
    ImGuiContext* ctx,
    ImGuiSettingsHandler* handler,
    ImGuiTextBuffer* buf
    );

static const char* DebugNodeTableGetSizingPolicyDesc(ImGuiTableFlags sizing_policy);

static float GetDraggedColumnOffset(
    ImGuiOldColumns* columns,
    int column_index
    );

static float GetColumnWidthEx(
    ImGuiOldColumns* columns,
    int column_index,
    bool before_resize = false
    );

static bool InputTextFilterCharacter(
    ImGuiContext* ctx,
    ImGuiInputTextState* state,
    unsigned int* p_char,
    ImGuiInputTextCallback callback,
    void* user_data,
    bool input_source_is_clipboard = false
    );

static ImVec2 InputTextCalcTextSize(
    ImGuiContext* ctx,
    const char* text_begin,
    const char* text_end_display,
    const char* text_end,
    const char** out_remaining = NULL,
    ImVec2* out_offset = NULL,
    ImDrawTextFlags flags = 0
    );

static int IMGUI_CDECL ShrinkWidthItemComparer(
    const void* lhs,
    const void* rhs
    );

static float CalcMaxPopupHeightFromItemCount(int items_count);

static const char* Items_ArrayGetter(
    void* data,
    int idx
    );

static const char* Items_SingleStringGetter(
    void* data,
    int idx
    );

IM_STATIC_ASSERT(IM_COUNTOF(GDataTypeInfo) = =ImGuiDataType_COUNT);

template <typename T>
static int DataTypeCompareT(
    const T* lhs,
    const T* rhs
    );

template <typename T>
static bool DataTypeClampT(
    T* v,
    const T* v_min,
    const T* v_max
    );

static float GetMinimumStepAtDecimalPrecision(int decimal_precision);
const char* ImParseFormatFindStart(const char* fmt);
const char* ImParseFormatFindEnd(const char* fmt);

const char* ImParseFormatTrimDecorations(
    const char* fmt,
    char* buf,
    size_t buf_size
    );

void ImParseFormatSanitizeForPrinting(
    const char* fmt_in,
    char* fmt_out,
    size_t fmt_out_size
    );

const char* ImParseFormatSanitizeForScanning(
    const char* fmt_in,
    char* fmt_out,
    size_t fmt_out_size
    );

template <typename TYPE>
static const char* ImAtoi(
    const char* src,
    TYPE* output
    );

int ImParseFormatPrecision(
    const char* fmt,
    int default_precision
    );

static void InputTextReconcileUndoState(
    ImGuiInputTextState* state,
    const char* old_buf,
    int old_length,
    const char* new_buf,
    int new_length
    );

static int* ImLowerBound(
    int* in_begin,
    int* in_end,
    int v
    );

static int InputTextLineIndexBuild(
    ImGuiInputTextFlags flags,
    ImGuiTextIndex* line_index,
    const char* buf,
    const char* buf_end,
    float wrap_width,
    int max_output_buffer_size,
    const char** out_buf_end
    );

static ImVec2 InputTextLineIndexGetPosOffset(
    ImGuiContext& g,
    ImGuiInputTextState* state,
    ImGuiTextIndex* line_index,
    const char* buf,
    const char* buf_end,
    int cursor_n
    );

static void ColorEditRestoreH(
    const float* col,
    float* H
    );

static void ColorEditRestoreHS(
    const float* col,
    float* H,
    float* S,
    float* V
    );

static void RenderArrowsForVerticalBar(
    ImDrawList* draw_list,
    ImVec2 pos,
    ImVec2 half_sz,
    float bar_w,
    float alpha
    );

static void TreeNodeStoreStackData(
    ImGuiTreeNodeFlags flags,
    float x1
    );

static int ImStrimatchlen(
    const char* s1,
    const char* s1_end,
    const char* s2
    );

static void BoxSelectPreStartDrag(
    ImGuiID id,
    ImGuiSelectionUserData clicked_item
    );

static void BoxSelectActivateDrag(
    ImGuiBoxSelectState* bs,
    ImGuiWindow* window
    );

static void BoxSelectDeactivateDrag(ImGuiBoxSelectState* bs);

static void BoxSelectScrollWithMouseDrag(
    ImGuiBoxSelectState* bs,
    ImGuiWindow* window,
    const ImRect& inner_r
    );

static void DebugLogMultiSelectRequests(
    const char* function,
    const ImGuiMultiSelectIO* io
    );

static ImRect CalcScopeRect(
    ImGuiMultiSelectTempData* ms,
    ImGuiWindow* window
    );

static int IMGUI_CDECL PairComparerByValueInt(
    const void* lhs,
    const void* rhs
    );

static void ImGuiSelectionBasicStorage_BatchSetItemSelected(
    ImGuiSelectionBasicStorage* selection,
    ImGuiID id,
    bool selected,
    int size_before_amends,
    int selection_order
    );

static void ImGuiSelectionBasicStorage_BatchFinish(
    ImGuiSelectionBasicStorage* selection,
    bool selected,
    int size_before_amends
    );

static float Plot_ArrayGetter(
    void* data,
    int idx
    );

static bool IsRootOfOpenMenuSet();
static int TabItemGetSectionIdx(const ImGuiTabItem* tab);

static int IMGUI_CDECL TabItemComparerBySection(
    const void* lhs,
    const void* rhs
    );

static int IMGUI_CDECL TabItemComparerByBeginOrder(
    const void* lhs,
    const void* rhs
    );

static ImGuiTabBar* GetTabBarFromTabBarRef(const ImGuiPtrOrIndex& ref);
static ImGuiPtrOrIndex GetTabBarRefFromTabBar(ImGuiTabBar* tab_bar);

static float TabBarCalcScrollableWidth(
    ImGuiTabBar* tab_bar,
    ImGuiTabBarSection* sections
    );

STBRP_DEF int stbrp_pack_rects(
    stbrp_context* context,
    stbrp_rect* rects,
    int num_rects
    );

STBRP_DEF void stbrp_init_target(
    stbrp_context* context,
    int width,
    int height,
    stbrp_node* nodes,
    int num_nodes
    );

STBRP_DEF void stbrp_setup_allow_out_of_mem(
    stbrp_context* context,
    int allow_out_of_mem
    );

STBRP_DEF void stbrp_setup_heuristic(
    stbrp_context* context,
    int heuristic
    );

STBTT_DEF int stbtt_BakeFontBitmap(
    const unsigned char* data,
    int offset,
    float pixel_height,
    unsigned char* pixels,
    int pw,
    int ph,
    int first_char,
    int num_chars,
    stbtt_bakedchar* chardata
    );

STBTT_DEF void stbtt_GetBakedQuad(
    const stbtt_bakedchar* chardata,
    int pw,
    int ph,
    int char_index,
    float* xpos,
    float* ypos,
    stbtt_aligned_quad* q,
    int opengl_fillrule
    );

STBTT_DEF void stbtt_GetScaledFontVMetrics(
    const unsigned char* fontdata,
    int index,
    float size,
    float* ascent,
    float* descent,
    float* lineGap
    );

STBTT_DEF int stbtt_PackBegin(
    stbtt_pack_context* spc,
    unsigned char* pixels,
    int width,
    int height,
    int stride_in_bytes,
    int padding,
    void* alloc_context
    );

STBTT_DEF void stbtt_PackEnd(stbtt_pack_context* spc);

STBTT_DEF int stbtt_PackFontRange(
    stbtt_pack_context* spc,
    const unsigned char* fontdata,
    int font_index,
    float font_size,
    int first_unicode_char_in_range,
    int num_chars_in_range,
    stbtt_packedchar* chardata_for_range
    );

STBTT_DEF int stbtt_PackFontRanges(
    stbtt_pack_context* spc,
    const unsigned char* fontdata,
    int font_index,
    stbtt_pack_range* ranges,
    int num_ranges
    );

STBTT_DEF void stbtt_PackSetOversampling(
    stbtt_pack_context* spc,
    unsigned int h_oversample,
    unsigned int v_oversample
    );

STBTT_DEF void stbtt_PackSetSkipMissingCodepoints(
    stbtt_pack_context* spc,
    int skip
    );

STBTT_DEF void stbtt_GetPackedQuad(
    const stbtt_packedchar* chardata,
    int pw,
    int ph,
    int char_index,
    float* xpos,
    float* ypos,
    stbtt_aligned_quad* q,
    int align_to_integer
    );

STBTT_DEF int stbtt_PackFontRangesGatherRects(
    stbtt_pack_context* spc,
    const stbtt_fontinfo* info,
    stbtt_pack_range* ranges,
    int num_ranges,
    stbrp_rect* rects
    );

STBTT_DEF void stbtt_PackFontRangesPackRects(
    stbtt_pack_context* spc,
    stbrp_rect* rects,
    int num_rects
    );

STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(
    stbtt_pack_context* spc,
    const stbtt_fontinfo* info,
    stbtt_pack_range* ranges,
    int num_ranges,
    stbrp_rect* rects
    );

STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char* data);

STBTT_DEF int stbtt_GetFontOffsetForIndex(
    const unsigned char* data,
    int index
    );

STBTT_DEF int stbtt_InitFont(
    stbtt_fontinfo* info,
    const unsigned char* data,
    int offset
    );

STBTT_DEF int stbtt_FindGlyphIndex(
    const stbtt_fontinfo* info,
    int unicode_codepoint
    );

STBTT_DEF float stbtt_ScaleForPixelHeight(
    const stbtt_fontinfo* info,
    float pixels
    );

STBTT_DEF float stbtt_ScaleForMappingEmToPixels(
    const stbtt_fontinfo* info,
    float pixels
    );

STBTT_DEF void stbtt_GetFontVMetrics(
    const stbtt_fontinfo* info,
    int* ascent,
    int* descent,
    int* lineGap
    );

STBTT_DEF int stbtt_GetFontVMetricsOS2(
    const stbtt_fontinfo* info,
    int* typoAscent,
    int* typoDescent,
    int* typoLineGap
    );

STBTT_DEF void stbtt_GetFontBoundingBox(
    const stbtt_fontinfo* info,
    int* x0,
    int* y0,
    int* x1,
    int* y1
    );

STBTT_DEF void stbtt_GetCodepointHMetrics(
    const stbtt_fontinfo* info,
    int codepoint,
    int* advanceWidth,
    int* leftSideBearing
    );

STBTT_DEF int stbtt_GetCodepointKernAdvance(
    const stbtt_fontinfo* info,
    int ch1,
    int ch2
    );

STBTT_DEF int stbtt_GetCodepointBox(
    const stbtt_fontinfo* info,
    int codepoint,
    int* x0,
    int* y0,
    int* x1,
    int* y1
    );

STBTT_DEF void stbtt_GetGlyphHMetrics(
    const stbtt_fontinfo* info,
    int glyph_index,
    int* advanceWidth,
    int* leftSideBearing
    );

STBTT_DEF int stbtt_GetGlyphKernAdvance(
    const stbtt_fontinfo* info,
    int glyph1,
    int glyph2
    );

STBTT_DEF int stbtt_GetGlyphBox(
    const stbtt_fontinfo* info,
    int glyph_index,
    int* x0,
    int* y0,
    int* x1,
    int* y1
    );

STBTT_DEF int stbtt_GetKerningTableLength(const stbtt_fontinfo* info);

STBTT_DEF int stbtt_GetKerningTable(
    const stbtt_fontinfo* info,
    stbtt_kerningentry* table,
    int table_length
    );

STBTT_DEF int stbtt_IsGlyphEmpty(
    const stbtt_fontinfo* info,
    int glyph_index
    );

STBTT_DEF int stbtt_GetCodepointShape(
    const stbtt_fontinfo* info,
    int unicode_codepoint,
    stbtt_vertex** vertices
    );

STBTT_DEF int stbtt_GetGlyphShape(
    const stbtt_fontinfo* info,
    int glyph_index,
    stbtt_vertex** vertices
    );

STBTT_DEF void stbtt_FreeShape(
    const stbtt_fontinfo* info,
    stbtt_vertex* vertices
    );

STBTT_DEF unsigned char* stbtt_FindSVGDoc(
    const stbtt_fontinfo* info,
    int gl
    );

STBTT_DEF int stbtt_GetCodepointSVG(
    const stbtt_fontinfo* info,
    int unicode_codepoint,
    const char** svg
    );

STBTT_DEF int stbtt_GetGlyphSVG(
    const stbtt_fontinfo* info,
    int gl,
    const char** svg
    );

STBTT_DEF void stbtt_FreeBitmap(
    unsigned char* bitmap,
    void* userdata
    );

STBTT_DEF unsigned char* stbtt_GetCodepointBitmap(
    const stbtt_fontinfo* info,
    float scale_x,
    float scale_y,
    int codepoint,
    int* width,
    int* height,
    int* xoff,
    int* yoff
    );

STBTT_DEF unsigned char* stbtt_GetCodepointBitmapSubpixel(
    const stbtt_fontinfo* info,
    float scale_x,
    float scale_y,
    float shift_x,
    float shift_y,
    int codepoint,
    int* width,
    int* height,
    int* xoff,
    int* yoff
    );

STBTT_DEF void stbtt_MakeCodepointBitmap(
    const stbtt_fontinfo* info,
    unsigned char* output,
    int out_w,
    int out_h,
    int out_stride,
    float scale_x,
    float scale_y,
    int codepoint
    );

STBTT_DEF void stbtt_MakeCodepointBitmapSubpixel(
    const stbtt_fontinfo* info,
    unsigned char* output,
    int out_w,
    int out_h,
    int out_stride,
    float scale_x,
    float scale_y,
    float shift_x,
    float shift_y,
    int codepoint
    );

STBTT_DEF void stbtt_MakeCodepointBitmapSubpixelPrefilter(
    const stbtt_fontinfo* info,
    unsigned char* output,
    int out_w,
    int out_h,
    int out_stride,
    float scale_x,
    float scale_y,
    float shift_x,
    float shift_y,
    int oversample_x,
    int oversample_y,
    float* sub_x,
    float* sub_y,
    int codepoint
    );

STBTT_DEF void stbtt_GetCodepointBitmapBox(
    const stbtt_fontinfo* font,
    int codepoint,
    float scale_x,
    float scale_y,
    int* ix0,
    int* iy0,
    int* ix1,
    int* iy1
    );

STBTT_DEF void stbtt_GetCodepointBitmapBoxSubpixel(
    const stbtt_fontinfo* font,
    int codepoint,
    float scale_x,
    float scale_y,
    float shift_x,
    float shift_y,
    int* ix0,
    int* iy0,
    int* ix1,
    int* iy1
    );

STBTT_DEF unsigned char* stbtt_GetGlyphBitmap(
    const stbtt_fontinfo* info,
    float scale_x,
    float scale_y,
    int glyph,
    int* width,
    int* height,
    int* xoff,
    int* yoff
    );

STBTT_DEF unsigned char* stbtt_GetGlyphBitmapSubpixel(
    const stbtt_fontinfo* info,
    float scale_x,
    float scale_y,
    float shift_x,
    float shift_y,
    int glyph,
    int* width,
    int* height,
    int* xoff,
    int* yoff
    );

STBTT_DEF void stbtt_MakeGlyphBitmap(
    const stbtt_fontinfo* info,
    unsigned char* output,
    int out_w,
    int out_h,
    int out_stride,
    float scale_x,
    float scale_y,
    int glyph
    );

STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(
    const stbtt_fontinfo* info,
    unsigned char* output,
    int out_w,
    int out_h,
    int out_stride,
    float scale_x,
    float scale_y,
    float shift_x,
    float shift_y,
    int glyph
    );

STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(
    const stbtt_fontinfo* info,
    unsigned char* output,
    int out_w,
    int out_h,
    int out_stride,
    float scale_x,
    float scale_y,
    float shift_x,
    float shift_y,
    int oversample_x,
    int oversample_y,
    float* sub_x,
    float* sub_y,
    int glyph
    );

STBTT_DEF void stbtt_GetGlyphBitmapBox(
    const stbtt_fontinfo* font,
    int glyph,
    float scale_x,
    float scale_y,
    int* ix0,
    int* iy0,
    int* ix1,
    int* iy1
    );

STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(
    const stbtt_fontinfo* font,
    int glyph,
    float scale_x,
    float scale_y,
    float shift_x,
    float shift_y,
    int* ix0,
    int* iy0,
    int* ix1,
    int* iy1
    );

STBTT_DEF void stbtt_Rasterize(
    stbtt__bitmap* result,
    float flatness_in_pixels,
    stbtt_vertex* vertices,
    int num_verts,
    float scale_x,
    float scale_y,
    float shift_x,
    float shift_y,
    int x_off,
    int y_off,
    int invert,
    void* userdata
    );

STBTT_DEF void stbtt_FreeSDF(
    unsigned char* bitmap,
    void* userdata
    );

STBTT_DEF unsigned char* stbtt_GetGlyphSDF(
    const stbtt_fontinfo* info,
    float scale,
    int glyph,
    int padding,
    unsigned char onedge_value,
    float pixel_dist_scale,
    int* width,
    int* height,
    int* xoff,
    int* yoff
    );

STBTT_DEF unsigned char* stbtt_GetCodepointSDF(
    const stbtt_fontinfo* info,
    float scale,
    int codepoint,
    int padding,
    unsigned char onedge_value,
    float pixel_dist_scale,
    int* width,
    int* height,
    int* xoff,
    int* yoff
    );

STBTT_DEF int stbtt_FindMatchingFont(
    const unsigned char* fontdata,
    const char* name,
    int flags
    );

STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(
    const char* s1,
    int len1,
    const char* s2,
    int len2
    );

STBTT_DEF const char* stbtt_GetFontNameString(
    const stbtt_fontinfo* font,
    int* length,
    int platformID,
    int encodingID,
    int languageID,
    int nameID
    );

static int InputTextCallback(ImGuiInputTextCallbackData* data);

stb_uint stb_compress(
    stb_uchar* out,
    stb_uchar* in,
    stb_uint len
    );

static bool binary_to_compressed_c(
    const char* filename,
    const char* symbol,
    SourceEncoding source_encoding,
    bool use_compression,
    bool use_static
    );

int main(
    int argc,
    char** argv
    );

char Encode85Byte(unsigned int x);

static stb_uint stb_adler32(
    stb_uint adler32,
    stb_uchar* buffer,
    stb_uint buflen
    );

static unsigned int stb_matchlen(
    stb_uchar* m1,
    stb_uchar* m2,
    stb_uint maxlen
    );

static void stb__write(unsigned char v);
static void stb_out2(stb_uint v);
static void stb_out3(stb_uint v);
static void stb_out4(stb_uint v);

static void outliterals(
    stb_uchar* in,
    int numlit
    );

static int stb_not_crap(
    int best,
    int dist
    );

static int stb_compress_chunk(
    stb_uchar* history,
    stb_uchar* start,
    stb_uchar* end,
    int length,
    int* pending_literals,
    stb_uchar** chash,
    stb_uint mask
    );

static int stb_compress_inner(
    stb_uchar* input,
    stb_uint length
    );

static void* ImGuiFreeTypeDefaultAllocFunc(
    size_t size,
    void* user_data
    );

static void ImGuiFreeTypeDefaultFreeFunc(
    void* ptr,
    void* user_data
    );

static const FT_Glyph_Metrics* ImGui_ImplFreeType_LoadGlyph(
    ImGui_ImplFreeType_FontSrcData* src_data,
    uint32_t codepoint
    );

static void ImGui_ImplFreeType_BlitGlyph(
    const FT_Bitmap* ft_bitmap,
    uint32_t* dst,
    uint32_t dst_pitch
    );

static void* FreeType_Alloc(
    FT_Memory,
    long size
    );

static void FreeType_Free(
    FT_Memory,
    void* block
    );

static void* FreeType_Realloc(
    FT_Memory,
    long cur_size,
    long new_size,
    void* block
    );

static bool ImGui_ImplFreeType_LoaderInit(ImFontAtlas* atlas);
static void ImGui_ImplFreeType_LoaderShutdown(ImFontAtlas* atlas);

static bool ImGui_ImplFreeType_FontSrcInit(
    ImFontAtlas* atlas,
    ImFontConfig* src
    );

static void ImGui_ImplFreeType_FontSrcDestroy(
    ImFontAtlas* atlas,
    ImFontConfig* src
    );

static bool ImGui_ImplFreeType_FontBakedInit(
    ImFontAtlas* atlas,
    ImFontConfig* src,
    ImFontBaked* baked,
    void* loader_data_for_baked_src
    );

static void ImGui_ImplFreeType_FontBakedDestroy(
    ImFontAtlas* atlas,
    ImFontConfig* src,
    ImFontBaked* baked,
    void* loader_data_for_baked_src
    );

static bool ImGui_ImplFreeType_FontBakedLoadGlyph(
    ImFontAtlas* atlas,
    ImFontConfig* src,
    ImFontBaked* baked,
    void* loader_data_for_baked_src,
    ImWchar codepoint,
    ImFontGlyph* out_glyph,
    float* out_advance_x
    );

static bool ImGui_ImplFreetype_FontSrcContainsGlyph(
    ImFontAtlas* atlas,
    ImFontConfig* src,
    ImWchar codepoint
    );

static float ImLog10(float x);
static double ImLog10(double x);
static float ImSinh(float x);
static double ImSinh(double x);
static float ImAsinh(float x);
static double ImAsinh(double x);

template <typename TSet, typename TFlag>
static bool ImHasFlag(
    TSet set,
    TFlag flag
    );

template <typename TSet, typename TFlag>
static void ImFlipFlag(
    TSet& set,
    TFlag flag
    );

template <typename T>
static T ImRemap(
    T x,
    T x0,
    T x1,
    T y0,
    T y1
    );

template <typename T>
static T ImRemap01(
    T x,
    T x0,
    T x1
    );

static int ImPosMod(
    int l,
    int r
    );

static bool ImNan(double val);
static bool ImNanOrInf(double val);
static double ImConstrainNan(double val);
static double ImConstrainInf(double val);
static double ImConstrainLog(double val);
static double ImConstrainTime(double val);

static bool ImAlmostEqual(
    double v1,
    double v2,
    int ulp = 2
    );

template <typename T>
static T ImMinArray(
    const T* values,
    int count
    );

template <typename T>
static T ImMaxArray(
    const T* values,
    int count
    );

template <typename T>
static void ImMinMaxArray(
    const T* values,
    int count,
    T* min_out,
    T* max_out
    );

template <typename T>
static T ImSum(
    const T* values,
    int count
    );

template <typename T>
static double ImMean(
    const T* values,
    int count
    );

template <typename T>
static double ImStdDev(
    const T* values,
    int count
    );

static ImU32 ImMixU32(
    ImU32 a,
    ImU32 b,
    ImU32 s
    );

static ImU32 ImLerpU32(
    const ImU32* colors,
    int size,
    float t
    );

static ImU32 ImAlphaU32(
    ImU32 col,
    float alpha
    );

template <typename T>
static bool ImOverlaps(
    T min_a,
    T max_a,
    T min_b,
    T max_b
    );

static ImPlotTime operator + (
    const ImPlotTime& lhs,
    const ImPlotTime& rhs
    );

static ImPlotTime operator - (
    const ImPlotTime& lhs,
    const ImPlotTime& rhs
    );

static bool operator == (
    const ImPlotTime& lhs,
    const ImPlotTime& rhs
    );

static bool operator < (
    const ImPlotTime& lhs,
    const ImPlotTime& rhs
    );

static bool operator > (
    const ImPlotTime& lhs,
    const ImPlotTime& rhs
    );

static bool operator <= (
    const ImPlotTime& lhs,
    const ImPlotTime& rhs
    );

static bool operator >= (
    const ImPlotTime& lhs,
    const ImPlotTime& rhs
    );

static IMPLOT_INLINE float ImInvSqrt(float x);
void mola_viz_imgui_register_default_handlers();
MRPT_INITIALIZER(do_register_MolaVizImGui);
void mola_viz_imgui_register_default_handlers();

int main(
    ] int argc,
    ] char** argv
    );

static bool eval(Cli& cli);
static void do_kitti_eval_error(Cli& cli);

int main(
    int argc,
    char** argv
    );

static void parse_calib_line(
    const std::string& line,
    Eigen::Matrix<double, 3, 4>& M
    );

std::vector<Matrix> loadPoses_tum_format(
    Cli& cli,
    const std::string& file_name,
    const std::string& calib_file,
    bool isGT
    );

std::vector<Matrix> loadPoses(string file_name);
vector<float> trajectoryDistances(vector<Matrix>& poses);

int32_t lastFrameFromSegmentLength(
    vector<float>& dist,
    int32_t first_frame,
    float len
    );

float rotationError(Matrix& pose_error);
float translationError(Matrix& pose_error);

vector<errors> calcSequenceErrors(
    vector<Matrix>& poses_gt,
    vector<Matrix>& poses_result
    );

void saveSequenceErrors(
    vector<errors>& err,
    string file_name
    );

void savePathPlot(
    vector<Matrix>& poses_gt,
    vector<Matrix>& poses_result,
    string file_name
    );

vector<int32_t> computeRoi(
    vector<Matrix>& poses_gt,
    vector<Matrix>& poses_result
    );

void plotPathPlot(
    Cli& cli,
    string dir,
    vector<int32_t>& roi,
    int32_t idx
    );

void saveErrorPlots(
    vector<errors>& seq_err,
    string plot_error_dir,
    const char* prefix
    );

void plotErrorPlots(
    Cli& cli,
    string dir,
    const char* prefix
    );

void saveStats(
    vector<errors> err,
    string dir
    );

MRPT_INITIALIZER(do_register_EurocDataset);
MRPT_INITIALIZER(do_register_Kitti360Dataset);
MRPT_INITIALIZER(do_register_KittiOdometryDataset);
MRPT_INITIALIZER(do_register_MulranDataset);
MRPT_INITIALIZER(do_register_ParisLucoDataset);

static void build_list_files(
    const std::string& dir,
    const std::string& file_extension,
    std::vector<std::string>& out_lst
    );

MRPT_FILL_ENUM(InitLocalization::FixedPose);
MRPT_FILL_ENUM(InitLocalization::FromStateEstimator);
MRPT_FILL_ENUM(InitLocalization::PitchAndRollFromIMU);

int main(
    int argc,
    char** argv
    );

static bool is_binary_georef(const std::string& fil);
void run_sm_georef(Cli& cli);

int main(
    int argc,
    char** argv
    );

void run_traj_georef(Cli& cli);

int main(
    int argc,
    char** argv
    );

int main();
int main();
int main();
int main();
int main();
int main();
MRPT_ENUM_TYPE_BEGIN_NAMESPACE(mola::state_estimation_smoother, mola::state_estimation_smoother::KinematicModel) MRPT_FILL_ENUM(KinematicModel MRPT_FILL_ENUM(KinematicModel::Tricycle);

int main(
    ] int argc,
    ] char** argv
    );

int main(
    int argc,
    char** argv
    );

IMPLEMENTS_MRPT_OBJECT(
    StateEstimationSmoother,
    mola::ExecutableBase,
    mola::state_estimation_smoother
    );

int main(
    ] int argc,
    ] char** argv
    );

int main(
    ] int argc,
    ] char** argv
    );

int main(
    int argc,
    char** argv
    );

int main(
    ] int argc,
    ] char** argv
    );

int main(
    int argc,
    char** argv
    );

int main(
    ] int argc,
    ] char** argv
    );

int main(
    int argc,
    char** argv
    );

int main();

int main(
    ] int argc,
    ] char** argv
    );

int main();

int main(
    ] int argc,
    ] char** argv
    );

int main(
    ] int argc,
    ] char** argv
    );

int main(
    ] int argc,
    ] char** argv
    );

// macros

#define ALLEGRO_HAS_CLIPBOARD
#define ALLEGRO_HAS_DRAW_INDEXED_PRIM
#define APIENTRYP
#define BOOST_TEST_MODULE
#define CALL_INSTANTIATE_FOR_NUMERIC_TYPES()

#define CHECKBOX_FLAG( \
    flags, \
    flag \
    )

#define D3DFVF_CUSTOMVERTEX
#define DBT_DEVNODES_CHANGED

#define DE_MULTIPLY( \
    color, \
    alpha \
    )

#define DLL_EXT
#define DOCKING_HOST_DRAW_CHANNEL_BG
#define DOCKING_HOST_DRAW_CHANNEL_FG
#define DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE
#define DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2

#define DRAW_VERT_IMGUI_TO_ALLEGRO( \
    DST, \
    SRC \
    )

#define ENSURE_YAML_ENTRY_EXISTS( \
    _c, \
    _name \
    )

#define FT_CEIL(X)
#define FT_SCALEFACTOR

#define GET_DELTA( \
    inp, \
    inp_end, \
    delta \
    )

#define GL3W_ERROR_INIT
#define GL3W_ERROR_LIBRARY_OPEN
#define GL3W_ERROR_OPENGL_VERSION
#define GL3W_OK
#define GLAPI
#define GLFW_ACCUM_ALPHA_BITS
#define GLFW_ACCUM_BLUE_BITS
#define GLFW_ACCUM_GREEN_BITS
#define GLFW_ACCUM_RED_BITS
#define GLFW_ALPHA_BITS
#define GLFW_ANY_RELEASE_BEHAVIOR
#define GLFW_API_UNAVAILABLE
#define GLFW_ARROW_CURSOR
#define GLFW_AUTO_ICONIFY
#define GLFW_AUX_BUFFERS
#define GLFW_BLUE_BITS
#define GLFW_CLIENT_API
#define GLFW_CONNECTED
#define GLFW_CONTEXT_NO_ERROR
#define GLFW_CONTEXT_RELEASE_BEHAVIOR
#define GLFW_CONTEXT_REVISION
#define GLFW_CONTEXT_ROBUSTNESS
#define GLFW_CONTEXT_VERSION_MAJOR
#define GLFW_CONTEXT_VERSION_MINOR
#define GLFW_CROSSHAIR_CURSOR
#define GLFW_CURSOR
#define GLFW_CURSOR_DISABLED
#define GLFW_CURSOR_HIDDEN
#define GLFW_CURSOR_NORMAL
#define GLFW_DECORATED
#define GLFW_DEPTH_BITS
#define GLFW_DISCONNECTED
#define GLFW_DONT_CARE
#define GLFW_DOUBLEBUFFER
#define GLFW_FALSE
#define GLFW_FLOATING
#define GLFW_FOCUSED
#define GLFW_FORMAT_UNAVAILABLE
#define GLFW_GREEN_BITS
#define GLFW_HAND_CURSOR
#define GLFW_HAS_CREATECURSOR
#define GLFW_HAS_FOCUS_ON_SHOW
#define GLFW_HAS_FOCUS_WINDOW
#define GLFW_HAS_GAMEPAD_API
#define GLFW_HAS_GETERROR
#define GLFW_HAS_GETKEYNAME
#define GLFW_HAS_GETPLATFORM
#define GLFW_HAS_MONITOR_WORK_AREA
#define GLFW_HAS_MOUSE_PASSTHROUGH
#define GLFW_HAS_NEW_CURSORS
#define GLFW_HAS_OSX_WINDOW_POS_FIX
#define GLFW_HAS_PER_MONITOR_DPI
#define GLFW_HAS_VULKAN
#define GLFW_HAS_WAYLAND
#define GLFW_HAS_WINDOW_ALPHA
#define GLFW_HAS_WINDOW_HOVERED
#define GLFW_HAS_WINDOW_TOPMOST
#define GLFW_HAS_X11
#define GLFW_HAS_X11_OR_WAYLAND
#define GLFW_HRESIZE_CURSOR
#define GLFW_IBEAM_CURSOR
#define GLFW_ICONIFIED
#define GLFW_INVALID_ENUM
#define GLFW_INVALID_VALUE
#define GLFW_JOYSTICK_1
#define GLFW_JOYSTICK_10
#define GLFW_JOYSTICK_11
#define GLFW_JOYSTICK_12
#define GLFW_JOYSTICK_13
#define GLFW_JOYSTICK_14
#define GLFW_JOYSTICK_15
#define GLFW_JOYSTICK_16
#define GLFW_JOYSTICK_2
#define GLFW_JOYSTICK_3
#define GLFW_JOYSTICK_4
#define GLFW_JOYSTICK_5
#define GLFW_JOYSTICK_6
#define GLFW_JOYSTICK_7
#define GLFW_JOYSTICK_8
#define GLFW_JOYSTICK_9
#define GLFW_JOYSTICK_LAST
#define GLFW_KEY_0
#define GLFW_KEY_1
#define GLFW_KEY_2
#define GLFW_KEY_3
#define GLFW_KEY_4
#define GLFW_KEY_5
#define GLFW_KEY_6
#define GLFW_KEY_7
#define GLFW_KEY_8
#define GLFW_KEY_9
#define GLFW_KEY_A
#define GLFW_KEY_APOSTROPHE
#define GLFW_KEY_B
#define GLFW_KEY_BACKSLASH
#define GLFW_KEY_BACKSPACE
#define GLFW_KEY_C
#define GLFW_KEY_CAPS_LOCK
#define GLFW_KEY_COMMA
#define GLFW_KEY_D
#define GLFW_KEY_DELETE
#define GLFW_KEY_DOWN
#define GLFW_KEY_E
#define GLFW_KEY_END
#define GLFW_KEY_ENTER
#define GLFW_KEY_EQUAL
#define GLFW_KEY_ESCAPE
#define GLFW_KEY_F
#define GLFW_KEY_F1
#define GLFW_KEY_F10
#define GLFW_KEY_F11
#define GLFW_KEY_F12
#define GLFW_KEY_F13
#define GLFW_KEY_F14
#define GLFW_KEY_F15
#define GLFW_KEY_F16
#define GLFW_KEY_F17
#define GLFW_KEY_F18
#define GLFW_KEY_F19
#define GLFW_KEY_F2
#define GLFW_KEY_F20
#define GLFW_KEY_F21
#define GLFW_KEY_F22
#define GLFW_KEY_F23
#define GLFW_KEY_F24
#define GLFW_KEY_F25
#define GLFW_KEY_F3
#define GLFW_KEY_F4
#define GLFW_KEY_F5
#define GLFW_KEY_F6
#define GLFW_KEY_F7
#define GLFW_KEY_F8
#define GLFW_KEY_F9
#define GLFW_KEY_G
#define GLFW_KEY_GRAVE_ACCENT
#define GLFW_KEY_H
#define GLFW_KEY_HOME
#define GLFW_KEY_I
#define GLFW_KEY_INSERT
#define GLFW_KEY_J
#define GLFW_KEY_K
#define GLFW_KEY_KP_0
#define GLFW_KEY_KP_1
#define GLFW_KEY_KP_2
#define GLFW_KEY_KP_3
#define GLFW_KEY_KP_4
#define GLFW_KEY_KP_5
#define GLFW_KEY_KP_6
#define GLFW_KEY_KP_7
#define GLFW_KEY_KP_8
#define GLFW_KEY_KP_9
#define GLFW_KEY_KP_ADD
#define GLFW_KEY_KP_DECIMAL
#define GLFW_KEY_KP_DIVIDE
#define GLFW_KEY_KP_ENTER
#define GLFW_KEY_KP_EQUAL
#define GLFW_KEY_KP_MULTIPLY
#define GLFW_KEY_KP_SUBTRACT
#define GLFW_KEY_L
#define GLFW_KEY_LAST
#define GLFW_KEY_LEFT
#define GLFW_KEY_LEFT_ALT
#define GLFW_KEY_LEFT_BRACKET
#define GLFW_KEY_LEFT_CONTROL
#define GLFW_KEY_LEFT_SHIFT
#define GLFW_KEY_LEFT_SUPER
#define GLFW_KEY_M
#define GLFW_KEY_MENU
#define GLFW_KEY_MINUS
#define GLFW_KEY_N
#define GLFW_KEY_NUM_LOCK
#define GLFW_KEY_O
#define GLFW_KEY_P
#define GLFW_KEY_PAGE_DOWN
#define GLFW_KEY_PAGE_UP
#define GLFW_KEY_PAUSE
#define GLFW_KEY_PERIOD
#define GLFW_KEY_PRINT_SCREEN
#define GLFW_KEY_Q
#define GLFW_KEY_R
#define GLFW_KEY_RIGHT
#define GLFW_KEY_RIGHT_ALT
#define GLFW_KEY_RIGHT_BRACKET
#define GLFW_KEY_RIGHT_CONTROL
#define GLFW_KEY_RIGHT_SHIFT
#define GLFW_KEY_RIGHT_SUPER
#define GLFW_KEY_S
#define GLFW_KEY_SCROLL_LOCK
#define GLFW_KEY_SEMICOLON
#define GLFW_KEY_SLASH
#define GLFW_KEY_SPACE
#define GLFW_KEY_T
#define GLFW_KEY_TAB
#define GLFW_KEY_U
#define GLFW_KEY_UNKNOWN
#define GLFW_KEY_UP
#define GLFW_KEY_V
#define GLFW_KEY_W
#define GLFW_KEY_WORLD_1
#define GLFW_KEY_WORLD_2
#define GLFW_KEY_X
#define GLFW_KEY_Y
#define GLFW_KEY_Z
#define GLFW_LOSE_CONTEXT_ON_RESET
#define GLFW_MAXIMIZED
#define GLFW_MOD_ALT
#define GLFW_MOD_CONTROL
#define GLFW_MOD_SHIFT
#define GLFW_MOD_SUPER
#define GLFW_MOUSE_BUTTON_1
#define GLFW_MOUSE_BUTTON_2
#define GLFW_MOUSE_BUTTON_3
#define GLFW_MOUSE_BUTTON_4
#define GLFW_MOUSE_BUTTON_5
#define GLFW_MOUSE_BUTTON_6
#define GLFW_MOUSE_BUTTON_7
#define GLFW_MOUSE_BUTTON_8
#define GLFW_MOUSE_BUTTON_LAST
#define GLFW_MOUSE_BUTTON_LEFT
#define GLFW_MOUSE_BUTTON_MIDDLE
#define GLFW_MOUSE_BUTTON_RIGHT
#define GLFW_NOT_INITIALIZED
#define GLFW_NO_API
#define GLFW_NO_CURRENT_CONTEXT
#define GLFW_NO_RESET_NOTIFICATION
#define GLFW_NO_ROBUSTNESS
#define GLFW_NO_WINDOW_CONTEXT
#define GLFW_OPENGL_ANY_PROFILE
#define GLFW_OPENGL_API
#define GLFW_OPENGL_COMPAT_PROFILE
#define GLFW_OPENGL_CORE_PROFILE
#define GLFW_OPENGL_DEBUG_CONTEXT
#define GLFW_OPENGL_ES_API
#define GLFW_OPENGL_FORWARD_COMPAT
#define GLFW_OPENGL_PROFILE
#define GLFW_OUT_OF_MEMORY
#define GLFW_PLATFORM_ERROR
#define GLFW_PRESS
#define GLFW_RED_BITS
#define GLFW_REFRESH_RATE
#define GLFW_RELEASE
#define GLFW_RELEASE_BEHAVIOR_FLUSH
#define GLFW_RELEASE_BEHAVIOR_NONE
#define GLFW_REPEAT
#define GLFW_RESIZABLE
#define GLFW_SAMPLES
#define GLFW_SRGB_CAPABLE
#define GLFW_STENCIL_BITS
#define GLFW_STEREO
#define GLFW_STICKY_KEYS
#define GLFW_STICKY_MOUSE_BUTTONS
#define GLFW_TRUE
#define GLFW_VERSION_COMBINED
#define GLFW_VERSION_MAJOR
#define GLFW_VERSION_MINOR
#define GLFW_VERSION_REVISION
#define GLFW_VERSION_UNAVAILABLE
#define GLFW_VISIBLE
#define GLFW_VRESIZE_CURSOR
#define GL_ACTIVE_TEXTURE
#define GL_ARB_clip_control
#define GL_ARRAY_BUFFER
#define GL_ARRAY_BUFFER_BINDING
#define GL_BACK
#define GL_BLEND
#define GL_BLEND_DST_ALPHA
#define GL_BLEND_DST_RGB
#define GL_BLEND_EQUATION_ALPHA
#define GL_BLEND_EQUATION_RGB
#define GL_BLEND_SRC_ALPHA
#define GL_BLEND_SRC_RGB
#define GL_CALL(_CALL)
#define GL_CALL(_CALL)
#define GL_CLAMP_TO_EDGE
#define GL_CLIP_ORIGIN
#define GL_COLOR_BUFFER_BIT
#define GL_COMPILE_STATUS
#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT
#define GL_CONTEXT_PROFILE_MASK
#define GL_CULL_FACE
#define GL_CURRENT_PROGRAM
#define GL_DEPTH_TEST
#define GL_ELEMENT_ARRAY_BUFFER
#define GL_ELEMENT_ARRAY_BUFFER_BINDING
#define GL_EXTENSIONS
#define GL_FALSE
#define GL_FILL
#define GL_FLOAT
#define GL_FRAGMENT_SHADER
#define GL_FRAMEBUFFER_SRGB
#define GL_FRONT
#define GL_FRONT_AND_BACK
#define GL_FUNC_ADD
#define GL_INFO_LOG_LENGTH
#define GL_LINEAR
#define GL_LINK_STATUS
#define GL_MAJOR_VERSION
#define GL_MAX_TEXTURE_SIZE
#define GL_MINOR_VERSION
#define GL_NEAREST
#define GL_NUM_EXTENSIONS
#define GL_ONE
#define GL_ONE_MINUS_SRC_ALPHA
#define GL_PACK_ALIGNMENT
#define GL_PIXEL_UNPACK_BUFFER
#define GL_PIXEL_UNPACK_BUFFER_BINDING
#define GL_POLYGON_MODE
#define GL_PRIMITIVE_RESTART
#define GL_RENDERER
#define GL_REPEAT
#define GL_RGBA
#define GL_SAMPLER_BINDING
#define GL_SCISSOR_BOX
#define GL_SCISSOR_TEST
#define GL_SRC_ALPHA
#define GL_STENCIL_TEST
#define GL_STREAM_DRAW
#define GL_TEXTURE0
#define GL_TEXTURE_2D
#define GL_TEXTURE_BINDING_2D
#define GL_TEXTURE_MAG_FILTER
#define GL_TEXTURE_MIN_FILTER
#define GL_TEXTURE_WRAP_S
#define GL_TEXTURE_WRAP_T
#define GL_TRIANGLES
#define GL_TRUE
#define GL_UNPACK_ALIGNMENT
#define GL_UNPACK_ROW_LENGTH
#define GL_UNSIGNED_BYTE
#define GL_UNSIGNED_INT
#define GL_UNSIGNED_SHORT
#define GL_UPPER_LEFT
#define GL_VENDOR
#define GL_VERSION
#define GL_VERSION_3_1
#define GL_VERSION_3_2
#define GL_VERSION_3_3
#define GL_VERTEX_ARRAY_BINDING
#define GL_VERTEX_ATTRIB_ARRAY_ENABLED
#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED
#define GL_VERTEX_ATTRIB_ARRAY_POINTER
#define GL_VERTEX_ATTRIB_ARRAY_SIZE
#define GL_VERTEX_ATTRIB_ARRAY_STRIDE
#define GL_VERTEX_ATTRIB_ARRAY_TYPE
#define GL_VERTEX_SHADER
#define GL_VIEWPORT
#define GTSAM_USES_BOOST

#define GTSAM_VERSION_AT_LEAST( \
    major, \
    minor, \
    patch \
    )

#define GetBufSize

#define HEADER_PIXEL( \
    data, \
    pixel \
    )

#define IMGUI_CHECKVERSION()
#define IMGUI_COL_TO_DX9_ARGB(_COL)
#define IMGUI_DEBUG_LOG(...)
#define IMGUI_DEBUG_LOG_ACTIVEID(...)
#define IMGUI_DEBUG_LOG_CLIPPER(...)
#define IMGUI_DEBUG_LOG_DOCKING(...)
#define IMGUI_DEBUG_LOG_ERROR(...)
#define IMGUI_DEBUG_LOG_FOCUS(...)
#define IMGUI_DEBUG_LOG_FONT(...)
#define IMGUI_DEBUG_LOG_INPUTROUTING(...)
#define IMGUI_DEBUG_LOG_IO(...)
#define IMGUI_DEBUG_LOG_NAV(...)
#define IMGUI_DEBUG_LOG_POPUP(...)
#define IMGUI_DEBUG_LOG_SELECTION(...)
#define IMGUI_DEBUG_LOG_VIEWPORT(...)
#define IMGUI_DEBUG_NAV_RECTS
#define IMGUI_DEBUG_NAV_SCORING

#define IMGUI_DEBUG_PRINTF( \
    _FMT, \
    ... \
    )

#define IMGUI_DEMO_MARKER(section)
#define IMGUI_FONT_SIZE_MAX
#define IMGUI_FONT_SIZE_THRESHOLD_FOR_LOADADVANCEXONLYMODE
#define IMGUI_IMPL_API
#define IMGUI_IMPL_VULKAN_MINIMUM_IMAGE_SAMPLER_POOL_SIZE
#define IMGUI_PAYLOAD_TYPE_COLOR_3F
#define IMGUI_PAYLOAD_TYPE_COLOR_4F
#define IMGUI_PAYLOAD_TYPE_WINDOW
#define IMGUI_TABLE_MAX_COLUMNS

#define IMGUI_TEST_ENGINE_ITEM_ADD( \
    _ID, \
    _BB, \
    _ITEM_DATA \
    )

#define IMGUI_TEST_ENGINE_ITEM_INFO( \
    _ID, \
    _LABEL, \
    _FLAGS \
    )

#define IMGUI_VERSION
#define IMGUI_VERSION_NUM
#define IMGUI_WINDOW_HARD_MIN_SIZE

#define IMPLOT_APPEND_CMAP( \
    name, \
    qual \
    )

#define IMPLOT_DEPRECATED(method)
#define IMPLOT_INLINE

#define IMPLOT_NORMALIZE2F_OVER_ZERO( \
    VX, \
    VY \
    )

#define IMPLOT_NUMERIC_TYPES
#define IMPLOT_TMP
#define IMPLOT_VERSION
#define IMPLOT_VERSION_NUM
#define IMSTB_TEXTEDIT_CHARTYPE
#define IMSTB_TEXTEDIT_CHARTYPE
#define IMSTB_TEXTEDIT_GETNEXTCHARINDEX
#define IMSTB_TEXTEDIT_GETPREVCHARINDEX
#define IMSTB_TEXTEDIT_GETWIDTH_NEWLINE
#define IMSTB_TEXTEDIT_POSITIONTYPE
#define IMSTB_TEXTEDIT_STRING
#define IMSTB_TEXTEDIT_UNDOCHARCOUNT
#define IMSTB_TEXTEDIT_UNDOCHARCOUNT
#define IMSTB_TEXTEDIT_UNDOSTATECOUNT
#define IMSTB_TEXTEDIT_UNDOSTATECOUNT
#define IMSTB_TEXTEDIT_memmove
#define IM_ALLOC(_SIZE)
#define IM_ARRAYSIZE
#define IM_ASSERT(_EXPR)

#define IM_ASSERT_USER_ERROR( \
    _EXPR, \
    _MSG \
    )

#define IM_ASSERT_USER_ERROR_RET( \
    _EXPR, \
    _MSG \
    )

#define IM_ASSERT_USER_ERROR_RETV( \
    _EXPR, \
    _RETV, \
    _MSG \
    )

#define IM_BITARRAY_CLEARBIT( \
    _ARRAY, \
    _N \
    )

#define IM_BITARRAY_TESTBIT( \
    _ARRAY, \
    _N \
    )

#define IM_CLAMP( \
    V, \
    MN, \
    MX \
    )

#define IM_COL32( \
    R, \
    G, \
    B, \
    A \
    )

#define IM_COL32_A_MASK
#define IM_COL32_A_SHIFT
#define IM_COL32_BLACK
#define IM_COL32_BLACK_TRANS
#define IM_COL32_B_SHIFT
#define IM_COL32_DISABLE
#define IM_COL32_G_SHIFT
#define IM_COL32_R_SHIFT

#define IM_COL32_SPLIT_RGB( \
    col, \
    r, \
    g, \
    b \
    )

#define IM_COL32_WHITE
#define IM_COUNTOF(_ARR)
#define IM_DEBUG_BREAK()
#define IM_DRAWLIST_ARCFAST_SAMPLE_MAX
#define IM_DRAWLIST_ARCFAST_TABLE_SIZE

#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC( \
    _RAD, \
    _MAXERROR \
    )

#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC_ERROR( \
    _N, \
    _RAD \
    )

#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC_R( \
    _N, \
    _MAXERROR \
    )

#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MAX
#define IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MIN
#define IM_DRAWLIST_TEX_LINES_WIDTH_MAX
#define IM_F32_TO_INT8_SAT(_VAL)
#define IM_F32_TO_INT8_UNBOUND(_VAL)

#define IM_FIXNORMAL2F( \
    VX, \
    VY \
    )

#define IM_FIXNORMAL2F_MAX_INVLEN2
#define IM_FONTGLYPH_INDEX_NOT_FOUND
#define IM_FONTGLYPH_INDEX_UNUSED
#define IM_FREE(_PTR)

#define IM_MAX( \
    A, \
    B \
    )

#define IM_MAX( \
    A, \
    B \
    )

#define IM_MEMALIGN( \
    _OFF, \
    _ALIGN \
    )

#define IM_MIN( \
    A, \
    B \
    )

#define IM_NEW(_TYPE)
#define IM_NEWLINE
#define IM_NEWLINE

#define IM_NORMALIZE2F_OVER_ZERO( \
    VX, \
    VY \
    )

#define IM_PI
#define IM_PLACEMENT_NEW(_PTR)
#define IM_PRIX64
#define IM_PRId64
#define IM_PRIu64

#define IM_RGB( \
    r, \
    g, \
    b \
    )

#define IM_ROUND(_VAL)
#define IM_ROUNDUP_TO_EVEN(_V)
#define IM_SATURATE(V)
#define IM_STATIC_ASSERT(_COND)
#define IM_STRINGIFY(_EXPR)
#define IM_STRINGIFY_HELPER(_EXPR)
#define IM_TABSIZE
#define IM_TRUNC(_VAL)
#define IM_UNICODE_CODEPOINT_INVALID
#define IM_UNICODE_CODEPOINT_MAX
#define IM_UNUSED(_VAR)
#define INSTANTIATE_MACRO(T)
#define ImAcos(X)

#define ImAtan2( \
    Y, \
    X \
    )

#define ImAtof(STR)
#define ImCeil(X)
#define ImCos(X)
#define ImDrawCallback_ResetRenderState

#define ImDrawCmd_AreSequentialIdxOffset( \
    CMD_0, \
    CMD_1 \
    )

#define ImDrawCmd_HeaderCompare( \
    CMD_LHS, \
    CMD_RHS \
    )

#define ImDrawCmd_HeaderCopy( \
    CMD_DST, \
    CMD_SRC \
    )

#define ImDrawCmd_HeaderSize
#define ImDrawFlags_RoundCornersAll
#define ImDrawFlags_RoundCornersAll
#define ImDrawIdx
#define ImFabs(X)

#define ImFmod( \
    X, \
    Y \
    )

#define ImFontAtlasRectId_GenerationMask_
#define ImFontAtlasRectId_GenerationShift_
#define ImFontAtlasRectId_IndexMask_
#define ImFontAtlasRectId_Invalid
#define ImGuiButtonFlags_AllowOverlap
#define ImGuiKeyOwner_Any
#define ImGuiKeyOwner_NoOwner
#define ImGuiKey_Aliases_BEGIN
#define ImGuiKey_Aliases_END
#define ImGuiKey_Gamepad_BEGIN
#define ImGuiKey_Gamepad_END
#define ImGuiKey_Keyboard_BEGIN
#define ImGuiKey_Keyboard_END
#define ImGuiKey_LegacyNativeKey_BEGIN
#define ImGuiKey_LegacyNativeKey_END
#define ImGuiKey_Mouse_BEGIN
#define ImGuiKey_Mouse_END
#define ImGuiKey_NavGamepadActivate
#define ImGuiKey_NavGamepadCancel
#define ImGuiKey_NavGamepadInput
#define ImGuiKey_NavGamepadMenu
#define ImGuiKey_NavGamepadTweakFast
#define ImGuiKey_NavGamepadTweakSlow
#define ImGuiKey_NavKeyboardTweakFast
#define ImGuiKey_NavKeyboardTweakSlow
#define ImGuiMod_Alt
#define ImGuiMod_Ctrl
#define ImGuiMod_None
#define ImGuiMod_Shift
#define ImGuiMod_Super
#define ImGuiSelectionUserData_Invalid
#define ImMemchr
#define ImSin(X)
#define ImSqrt(X)
#define ImStrlen

#define ImTextClassifierGet( \
    _BITS, \
    _CHAR_OFFSET \
    )

#define ImTextureID_Invalid

#define MAP_ANALOG( \
    KEY_NO, \
    _UNUSED, \
    AXIS_NO, \
    V0, \
    V1 \
    )

#define MAP_ANALOG( \
    KEY_NO, \
    VALUE, \
    V0, \
    V1 \
    )

#define MAP_BUTTON( \
    KEY_NO, \
    BUTTON_ENUM \
    )

#define MAP_BUTTON( \
    KEY_NO, \
    _UNUSED, \
    BUTTON_NO \
    )

#define MEMALIGN( \
    _SIZE, \
    _ALIGN \
    )

#define MOLA_ARG_N( \
    _1, \
    _2, \
    _3, \
    _4, \
    _5, \
    _6, \
    _7, \
    _8, \
    _9, \
    _10, \
    N, \
    ... \
    )

#define MOLA_KERNEL_VIZ_HAS_METRICS
#define MOLA_KERNEL_VIZ_HAS_MOVABLE_FRAMES
#define MOLA_NARG(...)
#define MOLA_NARG_I_(...)
#define MOLA_POSE_LIST_HAS_ID_KEYED_API
#define MOLA_POSE_LIST_HAS_KFM_POSE_PLUMBING
#define MOLA_REGISTER_MODULE(_classname)
#define MOLA_RSEQ_N()

#define MOLA_TEST_SETENV( \
    name, \
    val \
    )

#define MOLA_TEST_UNSETENV(name)

#define MOLA_VERSION_CHECK( \
    major, \
    minor, \
    patch \
    )

#define MOLA_VFUNC( \
    name, \
    n \
    )

#define MOLA_VFUNC_( \
    name, \
    n \
    )

#define PI
#define PRId64
#define PRIu64
#define SDLK_APOSTROPHE
#define SDLK_GRAVE
#define SDL_HAS_ALWAYS_ON_TOP
#define SDL_HAS_CAPTURE_AND_GLOBAL_MOUSE
#define SDL_HAS_CAPTURE_AND_GLOBAL_MOUSE
#define SDL_HAS_DISPLAY_EVENT
#define SDL_HAS_OPEN_URL
#define SDL_HAS_PER_MONITOR_DPI
#define SDL_HAS_SHOW_WINDOW_ACTIVATION_HINT
#define SDL_HAS_USABLE_DISPLAY_BOUNDS
#define SDL_HAS_VULKAN
#define SDL_HAS_WINDOW_ALPHA
#define SQRT_1_2
#define SQRT_3_2
#define STBRP_ASSERT(x)
#define STBRP_DEF
#define STBRP_SORT
#define STBRP__MAXVAL
#define STBTT_DEF
#define STBTT_MACSTYLE_BOLD
#define STBTT_MACSTYLE_DONTCARE
#define STBTT_MACSTYLE_ITALIC
#define STBTT_MACSTYLE_NONE
#define STBTT_MACSTYLE_UNDERSCORE
#define STBTT_POINT_SIZE(x)
#define STBTT_assert(x)
#define STBTT_fabs(x)

#define STBTT_fmod( \
    x, \
    y \
    )

#define STBTT_free( \
    x, \
    u \
    )

#define STBTT_iceil(x)
#define STBTT_ifloor(x)

#define STBTT_malloc( \
    x, \
    u \
    )

#define STBTT_pow( \
    x, \
    y \
    )

#define STBTT_sqrt(x)
#define STBTT_strlen(x)
#define STB_RECT_PACK_VERSION
#define STB_TEXTEDIT_K_BACKSPACE
#define STB_TEXTEDIT_K_DELETE
#define STB_TEXTEDIT_K_DOWN
#define STB_TEXTEDIT_K_LEFT
#define STB_TEXTEDIT_K_LINEEND
#define STB_TEXTEDIT_K_LINESTART
#define STB_TEXTEDIT_K_PGDOWN
#define STB_TEXTEDIT_K_PGUP
#define STB_TEXTEDIT_K_REDO
#define STB_TEXTEDIT_K_RIGHT
#define STB_TEXTEDIT_K_SHIFT
#define STB_TEXTEDIT_K_TEXTEND
#define STB_TEXTEDIT_K_TEXTSTART
#define STB_TEXTEDIT_K_UNDO
#define STB_TEXTEDIT_K_UP
#define STB_TEXTEDIT_K_WORDLEFT
#define STB_TEXTEDIT_K_WORDRIGHT
#define STB_TEXTEDIT_MOVELINEEND
#define STB_TEXTEDIT_MOVELINESTART
#define STB_TEXTEDIT_MOVEWORDLEFT
#define STB_TEXTEDIT_MOVEWORDRIGHT
#define STB__SCRAMBLE(h)

#define STB__TRY( \
    t, \
    p \
    )

#define TEST_CLASS_MOVE_COPY_CTORS(_classname)

#define TSL_RH_CHECK_THROW( \
    S, \
    E \
    )

#define TSL_RH_CHECK_THROW_EITHER( \
    S, \
    E1, \
    E2 \
    )

#define TSL_RH_LIKELY(exp)
#define TSL_RH_NB_PRIMES

#define TSL_RH_THROW_OR_TERMINATE( \
    ex, \
    msg \
    )

#define TSL_RH_UNUSED(x)
#define TSL_RH_VERSION_MAJOR
#define TSL_RH_VERSION_MINOR
#define TSL_RH_VERSION_PATCH
#define USYNERGY_FALSE
#define USYNERGY_IDLE_TIMEOUT
#define USYNERGY_IS_PACKET(pkt_id)
#define USYNERGY_MODIFIER_ALT
#define USYNERGY_MODIFIER_ALT_GR
#define USYNERGY_MODIFIER_CAPSLOCK
#define USYNERGY_MODIFIER_CTRL
#define USYNERGY_MODIFIER_LEVEL5LOCK
#define USYNERGY_MODIFIER_META
#define USYNERGY_MODIFIER_NUMLOCK
#define USYNERGY_MODIFIER_SCROLLOCK
#define USYNERGY_MODIFIER_SHIFT
#define USYNERGY_MODIFIER_WIN
#define USYNERGY_NUM_JOYSTICKS
#define USYNERGY_PROTOCOL_MAJOR
#define USYNERGY_PROTOCOL_MINOR
#define USYNERGY_RECEIVE_BUFFER_SIZE
#define USYNERGY_REPLY_BUFFER_SIZE
#define USYNERGY_TRACE_BUFFER_SIZE
#define USYNERGY_TRUE

#define VFUNC( \
    func, \
    ... \
    )

#define WM_DPICHANGED
#define WM_MOUSEHWHEEL

#define YAML_LOAD_MEMBER_OPT( \
    _varname, \
    _type \
    )

#define YAML_LOAD_MEMBER_REQ( \
    _varname, \
    _type \
    )

#define YAML_LOAD_OPT(...)

#define YAML_LOAD_OPT2( \
    _varname, \
    _type \
    )

#define YAML_LOAD_OPT3( \
    _param_str, \
    _varname, \
    _type \
    )

#define YAML_LOAD_OPT_DEG(...)

#define YAML_LOAD_OPT_DEG2( \
    _varname, \
    _type \
    )

#define YAML_LOAD_OPT_DEG3( \
    _param_str, \
    _varname, \
    _type \
    )

#define YAML_LOAD_REQ(...)

#define YAML_LOAD_REQ2( \
    _varname, \
    _type \
    )

#define YAML_LOAD_REQ3( \
    _param_str, \
    _varname, \
    _type \
    )

#define YAML_LOAD_REQ_DEG(...)

#define YAML_LOAD_REQ_DEG2( \
    _varname, \
    _type \
    )

#define YAML_LOAD_REQ_DEG3( \
    _param_str, \
    _varname, \
    _type \
    )

#define _CAT( \
    x, \
    y \
    )

#define _CAT_( \
    x, \
    y \
    )

#define _INSTANTIATE_FOR_NUMERIC_TYPES(chain)
#define _INSTANTIATE_FOR_NUMERIC_TYPES_1(T)
#define _INSTANTIATE_FOR_NUMERIC_TYPES_2(T)
#define _IsWindows10OrGreater()
#define _IsWindows8OrGreater()
#define _IsWindows8Point1OrGreater()
#define _IsWindowsVistaOrGreater()
#define __gl_glcorearb_h_
#define glActiveTexture
#define glAttachShader
#define glBindBuffer
#define glBindSampler
#define glBindTexture
#define glBindVertexArray
#define glBlendEquation
#define glBlendEquationSeparate
#define glBlendFuncSeparate
#define glBufferData
#define glBufferSubData
#define glClear
#define glClearColor
#define glCompileShader
#define glCreateProgram
#define glCreateShader
#define glDeleteBuffers
#define glDeleteProgram
#define glDeleteSamplers
#define glDeleteShader
#define glDeleteTextures
#define glDeleteVertexArrays
#define glDetachShader
#define glDisable
#define glDisableVertexAttribArray
#define glDrawElements
#define glDrawElementsBaseVertex
#define glEnable
#define glEnableVertexAttribArray
#define glFlush
#define glGenBuffers
#define glGenSamplers
#define glGenTextures
#define glGenVertexArrays
#define glGetAttribLocation
#define glGetError
#define glGetIntegerv
#define glGetProgramInfoLog
#define glGetProgramiv
#define glGetShaderInfoLog
#define glGetShaderiv
#define glGetString
#define glGetStringi
#define glGetUniformLocation
#define glGetVertexAttribPointerv
#define glGetVertexAttribiv
#define glIsEnabled
#define glIsProgram
#define glLinkProgram
#define glPixelStorei
#define glPolygonMode
#define glReadPixels
#define glSamplerParameteri
#define glScissor
#define glShaderSource
#define glTexImage2D
#define glTexParameteri
#define glTexSubImage2D
#define glUniform1i
#define glUniformMatrix4fv
#define glUseProgram
#define glVertexAttribPointer
#define glViewport

#define stb__hc( \
    q, \
    h, \
    c \
    )

#define stb__hc2( \
    q, \
    h, \
    c, \
    d \
    )

#define stb__hc3( \
    q, \
    c, \
    d, \
    e \
    )

#define stb__in2(x)
#define stb__in3(x)
#define stb__in4(x)

#define stb__nc( \
    b, \
    d \
    )

#define stb_out(v)
#define stbtt_vertex_type
#define tsl_rh_assert(expr)

#define va_copy( \
    dest, \
    src \
    )

Typedefs

typedef boost::mpl::list<tsl::rh::power_of_two_growth_policy<2>, tsl::rh::power_of_two_growth_policy<4>, tsl::rh::prime_growth_policy, tsl::rh::mod_growth_policy<>, tsl::rh::mod_growth_policy<std::ratio<7, 2>>> test_types

MIT License

Copyright (c) 2017 Thibaut Goetghebuer-Planchon tessil@gmx.com

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

typedef boost::mpl::list<tsl::robin_map<std::int64_t, std::int64_t>, tsl::robin_map<std::string, std::string>, tsl::robin_map<std::int64_t, std::int64_t, mod_hash<9>>, tsl::robin_map<std::string, std::string, mod_hash<9>>, tsl::robin_map<move_only_test, move_only_test, mod_hash<9>>, tsl::robin_map<copy_only_test, copy_only_test, mod_hash<9>>, tsl::robin_map<self_reference_member_test, self_reference_member_test, mod_hash<9>>, tsl::robin_map<move_only_test, move_only_test, mod_hash<9>, std::equal_to<move_only_test>, std::allocator<std::pair<move_only_test, move_only_test>>, true, tsl::rh::power_of_two_growth_policy<4>>, tsl::robin_pg_map<move_only_test, move_only_test, mod_hash<9>>, tsl::robin_map<move_only_test, move_only_test, mod_hash<9>, std::equal_to<move_only_test>, std::allocator<std::pair<move_only_test, move_only_test>>, false, tsl::rh::mod_growth_policy<>>, tsl::robin_map<copy_only_test, copy_only_test, mod_hash<9>, std::equal_to<copy_only_test>, std::allocator<std::pair<copy_only_test, copy_only_test>>, false, tsl::rh::power_of_two_growth_policy<4>>, tsl::robin_pg_map<copy_only_test, copy_only_test, mod_hash<9>>, tsl::robin_map<copy_only_test, copy_only_test, mod_hash<9>, std::equal_to<copy_only_test>, std::allocator<std::pair<copy_only_test, copy_only_test>>, true, tsl::rh::mod_growth_policy<>>> test_types

MIT License

Copyright (c) 2017 Thibaut Goetghebuer-Planchon tessil@gmx.com

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

typedef boost::mpl::list<tsl::robin_set<std::int64_t>, tsl::robin_set<std::string>, tsl::robin_set<self_reference_member_test>, tsl::robin_set<move_only_test>, tsl::robin_pg_set<self_reference_member_test>, tsl::robin_set<move_only_test, std::hash<move_only_test>, std::equal_to<move_only_test>, std::allocator<move_only_test>, true, tsl::rh::prime_growth_policy>, tsl::robin_set<self_reference_member_test, std::hash<self_reference_member_test>, std::equal_to<self_reference_member_test>, std::allocator<self_reference_member_test>, true, tsl::rh::mod_growth_policy<>>, tsl::robin_set<move_only_test, std::hash<move_only_test>, std::equal_to<move_only_test>, std::allocator<move_only_test>, false, tsl::rh::mod_growth_policy<>>> test_types

MIT License

Copyright (c) 2017 Thibaut Goetghebuer-Planchon tessil@gmx.com

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

typedef struct GLFWcursor GLFWcursor

Opaque cursor object.

Opaque cursor object.

Added in version 3.1.

See also:

cursor_object

typedef struct GLFWimage GLFWimage

Image data.

Added in version 2.1. @glfw3 Removed format and bytes-per-pixel members.

See also:

cursor_custom

typedef int uSynergyBool

Boolean type.

typedef uSynergyBool (*uSynergyConnectFunc)(uSynergyCookie cookie)

Connect function.

This function is called when uSynergy needs to connect to the host. It doesn’t imply a network implementation or destination address, that must all be handled on the user side. The function should return USYNERGY_TRUE if a connection was established or USYNERGY_FALSE if it could not connect.

When network errors occur (e.g. uSynergySend or uSynergyReceive fail) then the connect call will be called again so the implementation of the function must close any old connections and clean up resources before retrying.

Parameters:

cookie

Cookie supplied in the Synergy context

typedef uSynergyBool (*uSynergySendFunc)(
    uSynergyCookie cookie,
    const uint8_t *buffer,
    int length
    )

Send function.

This function is called when uSynergy needs to send something over the default connection. It should return USYNERGY_TRUE if sending succeeded and USYNERGY_FALSE otherwise. This function should block until the send operation is completed.

Parameters:

cookie	Cookie supplied in the Synergy context
buffer	Address of buffer to send
length	Length of buffer to send

typedef uSynergyBool (*uSynergyReceiveFunc)(
    uSynergyCookie cookie,
    uint8_t *buffer,
    int maxLength,
    int *outLength
    )

Receive function.

This function is called when uSynergy needs to receive data from the default connection. It should return USYNERGY_TRUE if receiving data succeeded and USYNERGY_FALSE otherwise. This function should block until data has been received and wait for data to become available. If outLength is set to 0 upon completion it is assumed that the connection is alive, but still in a connecting state and needs time to settle.

Parameters:

cookie	Cookie supplied in the Synergy context
buffer	Address of buffer to receive data into
maxLength	Maximum amount of bytes to write into the receive buffer
outLength	Address of integer that receives the actual amount of bytes written into buffer

typedef void (*uSynergySleepFunc)(
    uSynergyCookie cookie,
    int timeMs
    )

Thread sleep function.

This function is called when uSynergy wants to suspend operation for a while before retrying an operation. It is mostly used when a socket times out or disconnect occurs to prevent uSynergy from continuously hammering a network connection in case the network is down.

Parameters:

cookie	Cookie supplied in the Synergy context
timeMs	Time to sleep the current thread (in milliseconds)

typedef uint32_t (*uSynergyGetTimeFunc)()

Get time function.

This function is called when uSynergy needs to know the current time. This is used to determine when timeouts have occurred. The time base should be a cyclic millisecond time value.

Returns:

Time value in milliseconds

typedef void (*uSynergyTraceFunc)(
    uSynergyCookie cookie,
    const char *text
    )

Trace function.

This function is called when uSynergy wants to trace something. It is optional to show these messages, but they are often useful when debugging. uSynergy only traces major events like connecting and disconnecting. Usually only a single trace is shown when the connection is established and no more trace are called.

Parameters:

cookie	Cookie supplied in the Synergy context
text	Text to be traced

typedef void (*uSynergyScreenActiveCallback)(
    uSynergyCookie cookie,
    uSynergyBool active
    )

Screen active callback.

This callback is called when Synergy makes the screen active or inactive. This callback is usually sent when the mouse enters or leaves the screen.

Parameters:

cookie	Cookie supplied in the Synergy context
active	Activation flag, 1 if the screen has become active, 0 if the screen has become inactive

typedef void (*uSynergyMouseCallback)(
    uSynergyCookie cookie,
    uint16_t x,
    uint16_t y,
    int16_t wheelX,
    int16_t wheelY,
    uSynergyBool buttonLeft,
    uSynergyBool buttonRight,
    uSynergyBool buttonMiddle
    )

Mouse callback.

This callback is called when a mouse events happens. The mouse X and Y position, wheel and button state is communicated in the message. It’s up to the user to interpret if this is a mouse up, down, double-click or other message.

Parameters:

cookie	Cookie supplied in the Synergy context
x	Mouse X position
y	Mouse Y position
wheelX	Mouse wheel X position
wheelY	Mouse wheel Y position
buttonLeft	Left button pressed status, 0 for released, 1 for pressed
buttonMiddle	Middle button pressed status, 0 for released, 1 for pressed
buttonRight	Right button pressed status, 0 for released, 1 for pressed

typedef void (*uSynergyKeyboardCallback)(
    uSynergyCookie cookie,
    uint16_t key,
    uint16_t modifiers,
    uSynergyBool down,
    uSynergyBool repeat
    )

Key event callback.

This callback is called when a key is pressed or released.

Parameters:

cookie	Cookie supplied in the Synergy context
key	Key code of key that was pressed or released
modifiers	Status of modifier keys (alt, shift, etc.)
down	Down or up status, 1 is key is pressed down, 0 if key is released (up)
repeat	Repeat flag, 1 if the key is down because the key is repeating, 0 if the key is initially pressed by the user

typedef void (*uSynergyJoystickCallback)(
    uSynergyCookie cookie,
    uint8_t joyNum,
    uint16_t buttons,
    int8_t leftStickX,
    int8_t leftStickY,
    int8_t rightStickX,
    int8_t rightStickY
    )

Joystick event callback.

This callback is called when a joystick stick or button changes. It is possible that multiple callbacks are fired when different sticks or buttons change as these are individual messages in the packet stream. Each callback will contain all the valid state for the different axes and buttons. The last callback received will represent the most current joystick state.

Parameters:

cookie	Cookie supplied in the Synergy context
joyNum	Joystick number, always in the range [0 … USYNERGY_NUM_JOYSTICKS>
buttons	Button pressed mask
leftStickX	Left stick X position, in range [-127 … 127]
leftStickY	Left stick Y position, in range [-127 … 127]
rightStickX	Right stick X position, in range [-127 … 127]
rightStickY	Right stick Y position, in range [-127 … 127]

typedef void (*uSynergyClipboardCallback)(
    uSynergyCookie cookie,
    enum uSynergyClipboardFormat format,
    const uint8_t *data,
    uint32_t size
    )

Clipboard event callback.

This callback is called when something is placed on the clipboard. Multiple callbacks may be fired for multiple clipboard formats if they are supported. The data provided is read-only and may not be modified by the application.

Parameters:

cookie	Cookie supplied in the Synergy context
format	Clipboard format
data	Memory area containing the clipboard raw data
size	Size of clipboard data

Global Variables

static std::map<std::string, LoadedModules> loaded_lib_handled

From internal_load_lib_modules()

static std::size_t nb_custom_allocs = 0

MIT License

Copyright (c) 2017 Thibaut Goetghebuer-Planchon tessil@gmx.com

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Global Functions

const std::map<std::string, LoadedModules>& get_loaded_modules()

Returns the current list of loaded module dyanmic libraries.

void internal_load_lib_modules(
    mrpt::system::COutputLogger& app,
    const std::vector<std::string>& lib_search_paths
    )

Loads all libs under lib_search_paths_.

See also:

setup()

void internal_load_lib_modules(
    mrpt::system::COutputLogger& app,
    const std::vector<std::string>& lib_search_paths
    )

Loads all libs under lib_search_paths_.

See also:

setup()

const std::map<std::string, LoadedModules>& get_loaded_modules()

Returns the current list of loaded module dyanmic libraries.

BOOST_AUTO_TEST_CASE_TEMPLATE(test_insert, HMap, test_types)

insert

BOOST_AUTO_TEST_CASE(test_emplace_hint)

emplace_hint

BOOST_AUTO_TEST_CASE(test_emplace)

emplace

BOOST_AUTO_TEST_CASE(test_try_emplace)

try_emplace

BOOST_AUTO_TEST_CASE(test_insert_or_assign)

insert_or_assign

BOOST_AUTO_TEST_CASE(test_range_erase_all)

erase

BOOST_AUTO_TEST_CASE(test_max_load_factor_extreme_factors)

max_load_factor

BOOST_AUTO_TEST_CASE(test_min_load_factor_extreme_factors)

min_load_factor

BOOST_AUTO_TEST_CASE(test_rehash_empty)

rehash

BOOST_AUTO_TEST_CASE(test_compare)

operator== and operator!=

BOOST_AUTO_TEST_CASE(test_clear)

clear

BOOST_AUTO_TEST_CASE(test_modify_value_through_iterator)

iterator.value()

BOOST_AUTO_TEST_CASE(test_extreme_bucket_count_value_construction)

constructor

BOOST_AUTO_TEST_CASE(test_assign_operator)

operator=(std::initializer_list)

BOOST_AUTO_TEST_CASE(test_move_constructor)

move/copy constructor/operator

BOOST_AUTO_TEST_CASE(test_at)

at

BOOST_AUTO_TEST_CASE(test_contains)

contains

BOOST_AUTO_TEST_CASE(test_equal_range)

equal_range

BOOST_AUTO_TEST_CASE(test_access_operator)

operator[]

BOOST_AUTO_TEST_CASE(test_swap)

swap

BOOST_AUTO_TEST_CASE(test_serialize_desearialize_empty)

serialize and deserialize

BOOST_AUTO_TEST_CASE(test_key_equal)

KeyEqual

BOOST_AUTO_TEST_CASE(test_heterogeneous_lookups)

other

BOOST_AUTO_TEST_CASE(test_empty_map)

Various operations on empty map

BOOST_AUTO_TEST_CASE(test_precalculated_hash)

Test precalculated hash

BOOST_AUTO_TEST_CASE(test_serialize_deserialize)

serialize and deserialize

static int16_t sNetToNative16(const unsigned char* value)

Read 16 bit integer in network byte order and convert to native byte order.

static int32_t sNetToNative32(const unsigned char* value)

Read 32 bit integer in network byte order and convert to native byte order.

static void sTrace(uSynergyContext* context, const char* text)

Trace text to client.

static void sAddString(uSynergyContext* context, const char* string)

Add string to reply packet.

static void sAddUInt8(uSynergyContext* context, uint8_t value)

Add uint8 to reply packet.

static void sAddUInt16(uSynergyContext* context, uint16_t value)

Add uint16 to reply packet.

static void sAddUInt32(uSynergyContext* context, uint32_t value)

Add uint32 to reply packet.

static uSynergyBool sSendReply(uSynergyContext* context)

Send reply packet.

static void sSendMouseCallback(uSynergyContext* context)

Call mouse callback after a mouse event.

static void sSendKeyboardCallback(
    uSynergyContext* context,
    uint16_t key,
    uint16_t modifiers,
    uSynergyBool down,
    uSynergyBool repeat
    )

Send keyboard callback when a key has been pressed or released.

static void sSendJoystickCallback(uSynergyContext* context, uint8_t joyNum)

Send joystick callback.

static void sSetDisconnected(uSynergyContext* context)

Mark context as being disconnected.

static void sUpdateContext(uSynergyContext* context)

Update a connected context.

void uSynergyInit(uSynergyContext* context)

Initialize uSynergy context.

This function initializes context for use. Call this function directly after creating the context, before filling in any configuration data in it. Not calling this function will cause undefined behavior.

Parameters:

context

Context to be initialized

void uSynergyUpdate(uSynergyContext* context)

Update uSynergy.

This function updates uSynergy and does the bulk of the work. It does connection management, receiving data, reconnecting after errors or timeouts and so on. It assumes that networking operations are blocking and it can suspend the current thread if it needs to wait. It is best practice to call uSynergyUpdate from a background thread so it is responsive.

Because uSynergy relies mostly on blocking calls it will mostly stay in thread sleep state waiting for system mutexes and won’t eat much memory.

uSynergyUpdate doesn’t do any memory allocations or have any side effects beyond those of the callbacks it calls.

Parameters:

context

Context to be updated

void uSynergySendClipboard(uSynergyContext* context, const char* text)

Send clipboard data.

This function sets new clipboard data and sends it to the server. Use this function if your client cuts or copies data onto the clipboard that it needs to share with the server.

Currently there is only support for plaintext, but HTML and image data could be supported with some effort.

Parameters:

context	Context to send clipboard data to
text	Text to set to the clipboard

void uSynergyInit(uSynergyContext* context)

Initialize uSynergy context.

This function initializes context for use. Call this function directly after creating the context, before filling in any configuration data in it. Not calling this function will cause undefined behavior.

Parameters:

context

Context to be initialized

void uSynergyUpdate(uSynergyContext* context)

Update uSynergy.

This function updates uSynergy and does the bulk of the work. It does connection management, receiving data, reconnecting after errors or timeouts and so on. It assumes that networking operations are blocking and it can suspend the current thread if it needs to wait. It is best practice to call uSynergyUpdate from a background thread so it is responsive.

Because uSynergy relies mostly on blocking calls it will mostly stay in thread sleep state waiting for system mutexes and won’t eat much memory.

uSynergyUpdate doesn’t do any memory allocations or have any side effects beyond those of the callbacks it calls.

Parameters:

context

Context to be updated

void uSynergySendClipboard(uSynergyContext* context, const char* text)

Send clipboard data.

This function sets new clipboard data and sends it to the server. Use this function if your client cuts or copies data onto the clipboard that it needs to share with the server.

Currently there is only support for plaintext, but HTML and image data could be supported with some effort.

Parameters:

context	Context to send clipboard data to
text	Text to set to the clipboard

Macros

#define BOOST_TEST_MODULE

MIT License

Copyright (c) 2017 Thibaut Goetghebuer-Planchon tessil@gmx.com

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

#define GLFW_FALSE

Zero.

Zero. Seriously. You don’t need to use this symbol in your code. It’s just just semantic sugar for the number 0. You can use 0 or false or _False or GL_FALSE or whatever you want.

#define GLFW_TRUE

One.

One. Seriously. You don’t need to use this symbol in your code. It’s just semantic sugar for the number 1. You can use 1 or true or _True or GL_TRUE or whatever you want.

#define MOLA_ARG_N(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...)

Picks the 11th argument - used internally by MOLA_NARG.

#define MOLA_KERNEL_VIZ_HAS_METRICS

Feature macro: when defined, VizInterface offers register_metric() / push_metric() and the mola::MetricChannel handle type, i.e. the streaming time-series “metrics” plotting mechanism. Lets out-of-repo modules detect the feature at compile time.

#define MOLA_KERNEL_VIZ_HAS_MOVABLE_FRAMES

Feature macro: when defined, VizInterface offers update_3d_object_frame() and the parentFrame argument of update_3d_object(), insert_point_cloud_with_decay(), and update_viewport_look_at(), i.e. named movable reference-frame nodes that child objects / camera targets can be resolved against. Lets out-of-repo modules (e.g. an older mola_lidar_odometry checkout) detect the feature at compile time.

#define MOLA_POSE_LIST_HAS_ID_KEYED_API

Feature macro: SearchablePoseList exposes the id-keyed API (insert(pose, id), setPoseById) used by the online gravity-rebake feature to keep distance-checkers in sync with per-KF pose corrections. Downstream packages in separate repos should guard usage with #if defined(MOLA_POSE_LIST_HAS_ID_KEYED_API) (combined with __has_include(<mola_pose_list/SearchablePoseList.h>)) to remain buildable against older mola_pose_list checkouts.

#define MOLA_POSE_LIST_HAS_KFM_POSE_PLUMBING

Feature macro: SearchablePoseList exposes countNearby() and the sensor-pose-as-key plumbing used by mola_lidar_odometry. Downstream packages should guard usage with #if defined(MOLA_POSE_LIST_HAS_KFM_POSE_PLUMBING).

#define MOLA_RSEQ_N()

Decreasing sequence used as the “ruler” for argument counting.

#define MOLA_VERSION_CHECK(major, minor, patch)

To be used in #if() checks for >= minimum MOLA versions.

#define MOLA_VFUNC(name, n)

Forces an extra expansion pass before concatenation (needed for correctness when either argument is itself a macro).

#define MOLA_VFUNC_(name, n)

Concatenates name and n after macro expansion of both.

#define TSL_RH_CHECK_THROW(S, E)

MIT License

Copyright (c) 2017 Thibaut Goetghebuer-Planchon tessil@gmx.com

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

#define TSL_RH_VERSION_MAJOR

MIT License

Copyright (c) 2017 Thibaut Goetghebuer-Planchon tessil@gmx.com

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

#define USYNERGY_IS_PACKET(pkt_id)

Parse a single client message, update state, send callbacks and send replies.

#define USYNERGY_MODIFIER_SHIFT

Keyboard constants.

#define USYNERGY_NUM_JOYSTICKS

Constants and limits.

#define VFUNC(func, ...)

Dispatch a variadic macro call to a numbered overload.

VFUNC(func, args...) expands to funcN(args...) where N is the number of arguments in args.

Parameters:

func	Base name of the macro family (without trailing digit).
…	Arguments forwarded verbatim to the selected overload.