From 9e962f0fde11c998bd46f2aa400de0498032729b Mon Sep 17 00:00:00 2001 From: rubin Date: Thu, 21 Mar 2024 10:47:02 +0300 Subject: [PATCH] added mimgui --- mimgui/cdefs.lua | 1961 +++++++++++++++++++++++++++++++++++++ mimgui/cimguidx9.dll | Bin 0 -> 543744 bytes mimgui/dx9.lua | 171 ++++ mimgui/imgui.lua | 2231 ++++++++++++++++++++++++++++++++++++++++++ mimgui/init.lua | 368 +++++++ 5 files changed, 4731 insertions(+) create mode 100644 mimgui/cdefs.lua create mode 100644 mimgui/cimguidx9.dll create mode 100644 mimgui/dx9.lua create mode 100644 mimgui/imgui.lua create mode 100644 mimgui/init.lua diff --git a/mimgui/cdefs.lua b/mimgui/cdefs.lua new file mode 100644 index 0000000..94407bd --- /dev/null +++ b/mimgui/cdefs.lua @@ -0,0 +1,1961 @@ +--[[ BEGIN AUTOGENERATED SEGMENT ]] +local cdecl = [[ +typedef struct ImVec2_Simple { float x; float y; } ImVec2_Simple; +typedef struct ImVec4_Simple { float x; float y; float z; float w;} ImVec4_Simple; +typedef struct ImColor_Simple { ImVec4_Simple Value;} ImColor_Simple; +typedef struct ImGuiStoragePair ImGuiStoragePair; +typedef struct ImGuiTextRange ImGuiTextRange; +typedef struct ImFontAtlasCustomRect ImFontAtlasCustomRect; +typedef struct ImVec4 ImVec4; +typedef struct ImVec2 ImVec2; +typedef struct ImGuiTextFilter ImGuiTextFilter; +typedef struct ImGuiTextBuffer ImGuiTextBuffer; +typedef struct ImGuiStyle ImGuiStyle; +typedef struct ImGuiStorage ImGuiStorage; +typedef struct ImGuiSizeCallbackData ImGuiSizeCallbackData; +typedef struct ImGuiPayload ImGuiPayload; +typedef struct ImGuiOnceUponAFrame ImGuiOnceUponAFrame; +typedef struct ImGuiListClipper ImGuiListClipper; +typedef struct ImGuiInputTextCallbackData ImGuiInputTextCallbackData; +typedef struct ImGuiIO ImGuiIO; +typedef struct ImGuiContext ImGuiContext; +typedef struct ImColor ImColor; +typedef struct ImFontGlyphRangesBuilder ImFontGlyphRangesBuilder; +typedef struct ImFontGlyph ImFontGlyph; +typedef struct ImFontConfig ImFontConfig; +typedef struct ImFontAtlas ImFontAtlas; +typedef struct ImFont ImFont; +typedef struct ImDrawVert ImDrawVert; +typedef struct ImDrawListSplitter ImDrawListSplitter; +typedef struct ImDrawListSharedData ImDrawListSharedData; +typedef struct ImDrawList ImDrawList; +typedef struct ImDrawData ImDrawData; +typedef struct ImDrawCmd ImDrawCmd; +typedef struct ImDrawChannel ImDrawChannel; +struct ImDrawChannel; +struct ImDrawCmd; +struct ImDrawData; +struct ImDrawList; +struct ImDrawListSharedData; +struct ImDrawListSplitter; +struct ImDrawVert; +struct ImFont; +struct ImFontAtlas; +struct ImFontConfig; +struct ImFontGlyph; +struct ImFontGlyphRangesBuilder; +struct ImColor; +struct ImGuiContext; +struct ImGuiIO; +struct ImGuiInputTextCallbackData; +struct ImGuiListClipper; +struct ImGuiOnceUponAFrame; +struct ImGuiPayload; +struct ImGuiSizeCallbackData; +struct ImGuiStorage; +struct ImGuiStyle; +struct ImGuiTextBuffer; +struct ImGuiTextFilter; +typedef void* ImTextureID; +typedef unsigned int ImGuiID; +typedef unsigned short ImWchar; +typedef int ImGuiCol; +typedef int ImGuiCond; +typedef int ImGuiDataType; +typedef int ImGuiDir; +typedef int ImGuiKey; +typedef int ImGuiNavInput; +typedef int ImGuiMouseCursor; +typedef int ImGuiStyleVar; +typedef int ImDrawCornerFlags; +typedef int ImDrawListFlags; +typedef int ImFontAtlasFlags; +typedef int ImGuiBackendFlags; +typedef int ImGuiColorEditFlags; +typedef int ImGuiConfigFlags; +typedef int ImGuiComboFlags; +typedef int ImGuiDragDropFlags; +typedef int ImGuiFocusedFlags; +typedef int ImGuiHoveredFlags; +typedef int ImGuiInputTextFlags; +typedef int ImGuiSelectableFlags; +typedef int ImGuiTabBarFlags; +typedef int ImGuiTabItemFlags; +typedef int ImGuiTreeNodeFlags; +typedef int ImGuiWindowFlags; +typedef int (*ImGuiInputTextCallback)(ImGuiInputTextCallbackData *data); +typedef void (*ImGuiSizeCallback)(ImGuiSizeCallbackData* data); +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 int64_t ImS64; +typedef uint64_t ImU64; +typedef void (*ImDrawCallback)(const ImDrawList* parent_list, const ImDrawCmd* cmd); +typedef unsigned short ImDrawIdx;typedef struct ImVector{int Size;int Capacity;void* Data;} ImVector; +typedef struct ImVector_float {int Size;int Capacity;float* Data;} ImVector_float; +typedef struct ImVector_ImWchar {int Size;int Capacity;ImWchar* Data;} ImVector_ImWchar; +typedef struct ImVector_ImDrawVert {int Size;int Capacity;ImDrawVert* Data;} ImVector_ImDrawVert; +typedef struct ImVector_ImFontGlyph {int Size;int Capacity;ImFontGlyph* Data;} ImVector_ImFontGlyph; +typedef struct ImVector_ImGuiTextRange {int Size;int Capacity;ImGuiTextRange* Data;} ImVector_ImGuiTextRange; +typedef struct ImVector_ImGuiStoragePair {int Size;int Capacity;ImGuiStoragePair* Data;} ImVector_ImGuiStoragePair; +typedef struct ImVector_ImDrawChannel {int Size;int Capacity;ImDrawChannel* Data;} ImVector_ImDrawChannel; +typedef struct ImVector_char {int Size;int Capacity;char* Data;} ImVector_char; +typedef struct ImVector_ImU32 {int Size;int Capacity;ImU32* Data;} ImVector_ImU32; +typedef struct ImVector_ImFontAtlasCustomRect {int Size;int Capacity;ImFontAtlasCustomRect* Data;} ImVector_ImFontAtlasCustomRect; +typedef struct ImVector_ImTextureID {int Size;int Capacity;ImTextureID* Data;} ImVector_ImTextureID; +typedef struct ImVector_ImFontConfig {int Size;int Capacity;ImFontConfig* Data;} ImVector_ImFontConfig; +typedef struct ImVector_ImFontPtr {int Size;int Capacity;ImFont** Data;} ImVector_ImFontPtr; +typedef struct ImVector_ImDrawCmd {int Size;int Capacity;ImDrawCmd* Data;} ImVector_ImDrawCmd; +typedef struct ImVector_ImVec4 {int Size;int Capacity;ImVec4* Data;} ImVector_ImVec4; +typedef struct ImVector_ImDrawIdx {int Size;int Capacity;ImDrawIdx* Data;} ImVector_ImDrawIdx; +typedef struct ImVector_ImVec2 {int Size;int Capacity;ImVec2* Data;} ImVector_ImVec2; +struct ImVec2 +{ + float x, y; +}; +struct ImVec4 +{ + float x, y, z, w; +}; +enum ImGuiWindowFlags_ +{ + ImGuiWindowFlags_None = 0, + ImGuiWindowFlags_NoTitleBar = 1 << 0, + ImGuiWindowFlags_NoResize = 1 << 1, + ImGuiWindowFlags_NoMove = 1 << 2, + ImGuiWindowFlags_NoScrollbar = 1 << 3, + ImGuiWindowFlags_NoScrollWithMouse = 1 << 4, + ImGuiWindowFlags_NoCollapse = 1 << 5, + ImGuiWindowFlags_AlwaysAutoResize = 1 << 6, + ImGuiWindowFlags_NoBackground = 1 << 7, + ImGuiWindowFlags_NoSavedSettings = 1 << 8, + ImGuiWindowFlags_NoMouseInputs = 1 << 9, + ImGuiWindowFlags_MenuBar = 1 << 10, + ImGuiWindowFlags_HorizontalScrollbar = 1 << 11, + ImGuiWindowFlags_NoFocusOnAppearing = 1 << 12, + ImGuiWindowFlags_NoBringToFrontOnFocus = 1 << 13, + ImGuiWindowFlags_AlwaysVerticalScrollbar= 1 << 14, + ImGuiWindowFlags_AlwaysHorizontalScrollbar=1<< 15, + ImGuiWindowFlags_AlwaysUseWindowPadding = 1 << 16, + ImGuiWindowFlags_NoNavInputs = 1 << 18, + ImGuiWindowFlags_NoNavFocus = 1 << 19, + ImGuiWindowFlags_UnsavedDocument = 1 << 20, + ImGuiWindowFlags_NoNav = ImGuiWindowFlags_NoNavInputs | ImGuiWindowFlags_NoNavFocus, + ImGuiWindowFlags_NoDecoration = ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoCollapse, + ImGuiWindowFlags_NoInputs = ImGuiWindowFlags_NoMouseInputs | ImGuiWindowFlags_NoNavInputs | ImGuiWindowFlags_NoNavFocus, + ImGuiWindowFlags_NavFlattened = 1 << 23, + ImGuiWindowFlags_ChildWindow = 1 << 24, + ImGuiWindowFlags_Tooltip = 1 << 25, + ImGuiWindowFlags_Popup = 1 << 26, + ImGuiWindowFlags_Modal = 1 << 27, + ImGuiWindowFlags_ChildMenu = 1 << 28 +}; +enum ImGuiInputTextFlags_ +{ + ImGuiInputTextFlags_None = 0, + ImGuiInputTextFlags_CharsDecimal = 1 << 0, + ImGuiInputTextFlags_CharsHexadecimal = 1 << 1, + ImGuiInputTextFlags_CharsUppercase = 1 << 2, + ImGuiInputTextFlags_CharsNoBlank = 1 << 3, + ImGuiInputTextFlags_AutoSelectAll = 1 << 4, + ImGuiInputTextFlags_EnterReturnsTrue = 1 << 5, + ImGuiInputTextFlags_CallbackCompletion = 1 << 6, + ImGuiInputTextFlags_CallbackHistory = 1 << 7, + ImGuiInputTextFlags_CallbackAlways = 1 << 8, + ImGuiInputTextFlags_CallbackCharFilter = 1 << 9, + ImGuiInputTextFlags_AllowTabInput = 1 << 10, + ImGuiInputTextFlags_CtrlEnterForNewLine = 1 << 11, + ImGuiInputTextFlags_NoHorizontalScroll = 1 << 12, + ImGuiInputTextFlags_AlwaysInsertMode = 1 << 13, + ImGuiInputTextFlags_ReadOnly = 1 << 14, + ImGuiInputTextFlags_Password = 1 << 15, + ImGuiInputTextFlags_NoUndoRedo = 1 << 16, + ImGuiInputTextFlags_CharsScientific = 1 << 17, + ImGuiInputTextFlags_CallbackResize = 1 << 18, + ImGuiInputTextFlags_Multiline = 1 << 20, + ImGuiInputTextFlags_NoMarkEdited = 1 << 21 +}; +enum ImGuiTreeNodeFlags_ +{ + ImGuiTreeNodeFlags_None = 0, + ImGuiTreeNodeFlags_Selected = 1 << 0, + ImGuiTreeNodeFlags_Framed = 1 << 1, + ImGuiTreeNodeFlags_AllowItemOverlap = 1 << 2, + ImGuiTreeNodeFlags_NoTreePushOnOpen = 1 << 3, + ImGuiTreeNodeFlags_NoAutoOpenOnLog = 1 << 4, + ImGuiTreeNodeFlags_DefaultOpen = 1 << 5, + ImGuiTreeNodeFlags_OpenOnDoubleClick = 1 << 6, + ImGuiTreeNodeFlags_OpenOnArrow = 1 << 7, + ImGuiTreeNodeFlags_Leaf = 1 << 8, + ImGuiTreeNodeFlags_Bullet = 1 << 9, + ImGuiTreeNodeFlags_FramePadding = 1 << 10, + ImGuiTreeNodeFlags_NavLeftJumpsBackHere = 1 << 13, + ImGuiTreeNodeFlags_CollapsingHeader = ImGuiTreeNodeFlags_Framed | ImGuiTreeNodeFlags_NoTreePushOnOpen | ImGuiTreeNodeFlags_NoAutoOpenOnLog +}; +enum ImGuiSelectableFlags_ +{ + ImGuiSelectableFlags_None = 0, + ImGuiSelectableFlags_DontClosePopups = 1 << 0, + ImGuiSelectableFlags_SpanAllColumns = 1 << 1, + ImGuiSelectableFlags_AllowDoubleClick = 1 << 2, + ImGuiSelectableFlags_Disabled = 1 << 3 +}; +enum ImGuiComboFlags_ +{ + ImGuiComboFlags_None = 0, + ImGuiComboFlags_PopupAlignLeft = 1 << 0, + ImGuiComboFlags_HeightSmall = 1 << 1, + ImGuiComboFlags_HeightRegular = 1 << 2, + ImGuiComboFlags_HeightLarge = 1 << 3, + ImGuiComboFlags_HeightLargest = 1 << 4, + ImGuiComboFlags_NoArrowButton = 1 << 5, + ImGuiComboFlags_NoPreview = 1 << 6, + ImGuiComboFlags_HeightMask_ = ImGuiComboFlags_HeightSmall | ImGuiComboFlags_HeightRegular | ImGuiComboFlags_HeightLarge | ImGuiComboFlags_HeightLargest +}; +enum ImGuiTabBarFlags_ +{ + ImGuiTabBarFlags_None = 0, + ImGuiTabBarFlags_Reorderable = 1 << 0, + ImGuiTabBarFlags_AutoSelectNewTabs = 1 << 1, + ImGuiTabBarFlags_TabListPopupButton = 1 << 2, + ImGuiTabBarFlags_NoCloseWithMiddleMouseButton = 1 << 3, + ImGuiTabBarFlags_NoTabListScrollingButtons = 1 << 4, + ImGuiTabBarFlags_NoTooltip = 1 << 5, + ImGuiTabBarFlags_FittingPolicyResizeDown = 1 << 6, + ImGuiTabBarFlags_FittingPolicyScroll = 1 << 7, + ImGuiTabBarFlags_FittingPolicyMask_ = ImGuiTabBarFlags_FittingPolicyResizeDown | ImGuiTabBarFlags_FittingPolicyScroll, + ImGuiTabBarFlags_FittingPolicyDefault_ = ImGuiTabBarFlags_FittingPolicyResizeDown +}; +enum ImGuiTabItemFlags_ +{ + ImGuiTabItemFlags_None = 0, + ImGuiTabItemFlags_UnsavedDocument = 1 << 0, + ImGuiTabItemFlags_SetSelected = 1 << 1, + ImGuiTabItemFlags_NoCloseWithMiddleMouseButton = 1 << 2, + ImGuiTabItemFlags_NoPushId = 1 << 3 +}; +enum ImGuiFocusedFlags_ +{ + ImGuiFocusedFlags_None = 0, + ImGuiFocusedFlags_ChildWindows = 1 << 0, + ImGuiFocusedFlags_RootWindow = 1 << 1, + ImGuiFocusedFlags_AnyWindow = 1 << 2, + ImGuiFocusedFlags_RootAndChildWindows = ImGuiFocusedFlags_RootWindow | ImGuiFocusedFlags_ChildWindows +}; +enum ImGuiHoveredFlags_ +{ + ImGuiHoveredFlags_None = 0, + ImGuiHoveredFlags_ChildWindows = 1 << 0, + ImGuiHoveredFlags_RootWindow = 1 << 1, + ImGuiHoveredFlags_AnyWindow = 1 << 2, + ImGuiHoveredFlags_AllowWhenBlockedByPopup = 1 << 3, + ImGuiHoveredFlags_AllowWhenBlockedByActiveItem = 1 << 5, + ImGuiHoveredFlags_AllowWhenOverlapped = 1 << 6, + ImGuiHoveredFlags_AllowWhenDisabled = 1 << 7, + ImGuiHoveredFlags_RectOnly = ImGuiHoveredFlags_AllowWhenBlockedByPopup | ImGuiHoveredFlags_AllowWhenBlockedByActiveItem | ImGuiHoveredFlags_AllowWhenOverlapped, + ImGuiHoveredFlags_RootAndChildWindows = ImGuiHoveredFlags_RootWindow | ImGuiHoveredFlags_ChildWindows +}; +enum ImGuiDragDropFlags_ +{ + ImGuiDragDropFlags_None = 0, + ImGuiDragDropFlags_SourceNoPreviewTooltip = 1 << 0, + ImGuiDragDropFlags_SourceNoDisableHover = 1 << 1, + ImGuiDragDropFlags_SourceNoHoldToOpenOthers = 1 << 2, + ImGuiDragDropFlags_SourceAllowNullID = 1 << 3, + ImGuiDragDropFlags_SourceExtern = 1 << 4, + ImGuiDragDropFlags_SourceAutoExpirePayload = 1 << 5, + ImGuiDragDropFlags_AcceptBeforeDelivery = 1 << 10, + ImGuiDragDropFlags_AcceptNoDrawDefaultRect = 1 << 11, + ImGuiDragDropFlags_AcceptNoPreviewTooltip = 1 << 12, + ImGuiDragDropFlags_AcceptPeekOnly = ImGuiDragDropFlags_AcceptBeforeDelivery | ImGuiDragDropFlags_AcceptNoDrawDefaultRect +}; +enum ImGuiDataType_ +{ + ImGuiDataType_S8, + ImGuiDataType_U8, + ImGuiDataType_S16, + ImGuiDataType_U16, + ImGuiDataType_S32, + ImGuiDataType_U32, + ImGuiDataType_S64, + ImGuiDataType_U64, + ImGuiDataType_Float, + ImGuiDataType_Double, + ImGuiDataType_COUNT +}; +enum ImGuiDir_ +{ + ImGuiDir_None = -1, + ImGuiDir_Left = 0, + ImGuiDir_Right = 1, + ImGuiDir_Up = 2, + ImGuiDir_Down = 3, + ImGuiDir_COUNT +}; +enum ImGuiKey_ +{ + ImGuiKey_Tab, + ImGuiKey_LeftArrow, + ImGuiKey_RightArrow, + ImGuiKey_UpArrow, + ImGuiKey_DownArrow, + ImGuiKey_PageUp, + ImGuiKey_PageDown, + ImGuiKey_Home, + ImGuiKey_End, + ImGuiKey_Insert, + ImGuiKey_Delete, + ImGuiKey_Backspace, + ImGuiKey_Space, + ImGuiKey_Enter, + ImGuiKey_Escape, + ImGuiKey_KeyPadEnter, + ImGuiKey_A, + ImGuiKey_C, + ImGuiKey_V, + ImGuiKey_X, + ImGuiKey_Y, + ImGuiKey_Z, + ImGuiKey_COUNT +}; +enum ImGuiNavInput_ +{ + ImGuiNavInput_Activate, + ImGuiNavInput_Cancel, + ImGuiNavInput_Input, + ImGuiNavInput_Menu, + ImGuiNavInput_DpadLeft, + ImGuiNavInput_DpadRight, + ImGuiNavInput_DpadUp, + ImGuiNavInput_DpadDown, + ImGuiNavInput_LStickLeft, + ImGuiNavInput_LStickRight, + ImGuiNavInput_LStickUp, + ImGuiNavInput_LStickDown, + ImGuiNavInput_FocusPrev, + ImGuiNavInput_FocusNext, + ImGuiNavInput_TweakSlow, + ImGuiNavInput_TweakFast, + ImGuiNavInput_KeyMenu_, + ImGuiNavInput_KeyTab_, + ImGuiNavInput_KeyLeft_, + ImGuiNavInput_KeyRight_, + ImGuiNavInput_KeyUp_, + ImGuiNavInput_KeyDown_, + ImGuiNavInput_COUNT, + ImGuiNavInput_InternalStart_ = ImGuiNavInput_KeyMenu_ +}; +enum ImGuiConfigFlags_ +{ + ImGuiConfigFlags_None = 0, + ImGuiConfigFlags_NavEnableKeyboard = 1 << 0, + ImGuiConfigFlags_NavEnableGamepad = 1 << 1, + ImGuiConfigFlags_NavEnableSetMousePos = 1 << 2, + ImGuiConfigFlags_NavNoCaptureKeyboard = 1 << 3, + ImGuiConfigFlags_NoMouse = 1 << 4, + ImGuiConfigFlags_NoMouseCursorChange = 1 << 5, + ImGuiConfigFlags_IsSRGB = 1 << 20, + ImGuiConfigFlags_IsTouchScreen = 1 << 21 +}; +enum ImGuiBackendFlags_ +{ + ImGuiBackendFlags_None = 0, + ImGuiBackendFlags_HasGamepad = 1 << 0, + ImGuiBackendFlags_HasMouseCursors = 1 << 1, + ImGuiBackendFlags_HasSetMousePos = 1 << 2, + ImGuiBackendFlags_RendererHasVtxOffset = 1 << 3 +}; +enum ImGuiCol_ +{ + ImGuiCol_Text, + ImGuiCol_TextDisabled, + ImGuiCol_WindowBg, + ImGuiCol_ChildBg, + ImGuiCol_PopupBg, + ImGuiCol_Border, + ImGuiCol_BorderShadow, + ImGuiCol_FrameBg, + ImGuiCol_FrameBgHovered, + ImGuiCol_FrameBgActive, + ImGuiCol_TitleBg, + ImGuiCol_TitleBgActive, + ImGuiCol_TitleBgCollapsed, + ImGuiCol_MenuBarBg, + ImGuiCol_ScrollbarBg, + ImGuiCol_ScrollbarGrab, + ImGuiCol_ScrollbarGrabHovered, + ImGuiCol_ScrollbarGrabActive, + ImGuiCol_CheckMark, + ImGuiCol_SliderGrab, + ImGuiCol_SliderGrabActive, + ImGuiCol_Button, + ImGuiCol_ButtonHovered, + ImGuiCol_ButtonActive, + ImGuiCol_Header, + ImGuiCol_HeaderHovered, + ImGuiCol_HeaderActive, + ImGuiCol_Separator, + ImGuiCol_SeparatorHovered, + ImGuiCol_SeparatorActive, + ImGuiCol_ResizeGrip, + ImGuiCol_ResizeGripHovered, + ImGuiCol_ResizeGripActive, + ImGuiCol_Tab, + ImGuiCol_TabHovered, + ImGuiCol_TabActive, + ImGuiCol_TabUnfocused, + ImGuiCol_TabUnfocusedActive, + ImGuiCol_PlotLines, + ImGuiCol_PlotLinesHovered, + ImGuiCol_PlotHistogram, + ImGuiCol_PlotHistogramHovered, + ImGuiCol_TextSelectedBg, + ImGuiCol_DragDropTarget, + ImGuiCol_NavHighlight, + ImGuiCol_NavWindowingHighlight, + ImGuiCol_NavWindowingDimBg, + ImGuiCol_ModalWindowDimBg, + ImGuiCol_COUNT +}; +enum ImGuiStyleVar_ +{ + ImGuiStyleVar_Alpha, + ImGuiStyleVar_WindowPadding, + ImGuiStyleVar_WindowRounding, + ImGuiStyleVar_WindowBorderSize, + ImGuiStyleVar_WindowMinSize, + ImGuiStyleVar_WindowTitleAlign, + ImGuiStyleVar_ChildRounding, + ImGuiStyleVar_ChildBorderSize, + ImGuiStyleVar_PopupRounding, + ImGuiStyleVar_PopupBorderSize, + ImGuiStyleVar_FramePadding, + ImGuiStyleVar_FrameRounding, + ImGuiStyleVar_FrameBorderSize, + ImGuiStyleVar_ItemSpacing, + ImGuiStyleVar_ItemInnerSpacing, + ImGuiStyleVar_IndentSpacing, + ImGuiStyleVar_ScrollbarSize, + ImGuiStyleVar_ScrollbarRounding, + ImGuiStyleVar_GrabMinSize, + ImGuiStyleVar_GrabRounding, + ImGuiStyleVar_TabRounding, + ImGuiStyleVar_ButtonTextAlign, + ImGuiStyleVar_SelectableTextAlign, + ImGuiStyleVar_COUNT +}; +enum ImGuiColorEditFlags_ +{ + ImGuiColorEditFlags_None = 0, + ImGuiColorEditFlags_NoAlpha = 1 << 1, + ImGuiColorEditFlags_NoPicker = 1 << 2, + ImGuiColorEditFlags_NoOptions = 1 << 3, + ImGuiColorEditFlags_NoSmallPreview = 1 << 4, + ImGuiColorEditFlags_NoInputs = 1 << 5, + ImGuiColorEditFlags_NoTooltip = 1 << 6, + ImGuiColorEditFlags_NoLabel = 1 << 7, + ImGuiColorEditFlags_NoSidePreview = 1 << 8, + ImGuiColorEditFlags_NoDragDrop = 1 << 9, + ImGuiColorEditFlags_AlphaBar = 1 << 16, + ImGuiColorEditFlags_AlphaPreview = 1 << 17, + ImGuiColorEditFlags_AlphaPreviewHalf= 1 << 18, + ImGuiColorEditFlags_HDR = 1 << 19, + ImGuiColorEditFlags_DisplayRGB = 1 << 20, + ImGuiColorEditFlags_DisplayHSV = 1 << 21, + ImGuiColorEditFlags_DisplayHex = 1 << 22, + ImGuiColorEditFlags_Uint8 = 1 << 23, + ImGuiColorEditFlags_Float = 1 << 24, + ImGuiColorEditFlags_PickerHueBar = 1 << 25, + ImGuiColorEditFlags_PickerHueWheel = 1 << 26, + ImGuiColorEditFlags_InputRGB = 1 << 27, + ImGuiColorEditFlags_InputHSV = 1 << 28, + ImGuiColorEditFlags__OptionsDefault = ImGuiColorEditFlags_Uint8|ImGuiColorEditFlags_DisplayRGB|ImGuiColorEditFlags_InputRGB|ImGuiColorEditFlags_PickerHueBar, + ImGuiColorEditFlags__DisplayMask = ImGuiColorEditFlags_DisplayRGB|ImGuiColorEditFlags_DisplayHSV|ImGuiColorEditFlags_DisplayHex, + ImGuiColorEditFlags__DataTypeMask = ImGuiColorEditFlags_Uint8|ImGuiColorEditFlags_Float, + ImGuiColorEditFlags__PickerMask = ImGuiColorEditFlags_PickerHueWheel|ImGuiColorEditFlags_PickerHueBar, + ImGuiColorEditFlags__InputMask = ImGuiColorEditFlags_InputRGB|ImGuiColorEditFlags_InputHSV +}; +enum ImGuiMouseCursor_ +{ + ImGuiMouseCursor_None = -1, + ImGuiMouseCursor_Arrow = 0, + ImGuiMouseCursor_TextInput, + ImGuiMouseCursor_ResizeAll, + ImGuiMouseCursor_ResizeNS, + ImGuiMouseCursor_ResizeEW, + ImGuiMouseCursor_ResizeNESW, + ImGuiMouseCursor_ResizeNWSE, + ImGuiMouseCursor_Hand, + ImGuiMouseCursor_COUNT +}; +enum ImGuiCond_ +{ + ImGuiCond_Always = 1 << 0, + ImGuiCond_Once = 1 << 1, + ImGuiCond_FirstUseEver = 1 << 2, + ImGuiCond_Appearing = 1 << 3 +}; +struct ImGuiStyle +{ + float Alpha; + ImVec2 WindowPadding; + float WindowRounding; + float WindowBorderSize; + ImVec2 WindowMinSize; + ImVec2 WindowTitleAlign; + ImGuiDir WindowMenuButtonPosition; + float ChildRounding; + float ChildBorderSize; + float PopupRounding; + float PopupBorderSize; + ImVec2 FramePadding; + float FrameRounding; + float FrameBorderSize; + ImVec2 ItemSpacing; + ImVec2 ItemInnerSpacing; + ImVec2 TouchExtraPadding; + float IndentSpacing; + float ColumnsMinSpacing; + float ScrollbarSize; + float ScrollbarRounding; + float GrabMinSize; + float GrabRounding; + float TabRounding; + float TabBorderSize; + ImGuiDir ColorButtonPosition; + ImVec2 ButtonTextAlign; + ImVec2 SelectableTextAlign; + ImVec2 DisplayWindowPadding; + ImVec2 DisplaySafeAreaPadding; + float MouseCursorScale; + _Bool AntiAliasedLines; + _Bool AntiAliasedFill; + float CurveTessellationTol; + ImVec4 Colors[ImGuiCol_COUNT]; +}; +struct ImGuiIO +{ + ImGuiConfigFlags ConfigFlags; + ImGuiBackendFlags BackendFlags; + ImVec2 DisplaySize; + float DeltaTime; + float IniSavingRate; + const char* IniFilename; + const char* LogFilename; + float MouseDoubleClickTime; + float MouseDoubleClickMaxDist; + float MouseDragThreshold; + int KeyMap[ImGuiKey_COUNT]; + float KeyRepeatDelay; + float KeyRepeatRate; + void* UserData; + ImFontAtlas*Fonts; + float FontGlobalScale; + _Bool FontAllowUserScaling; + ImFont* FontDefault; + ImVec2 DisplayFramebufferScale; + _Bool MouseDrawCursor; + _Bool ConfigMacOSXBehaviors; + _Bool ConfigInputTextCursorBlink; + _Bool ConfigWindowsResizeFromEdges; + _Bool ConfigWindowsMoveFromTitleBarOnly; + const char* BackendPlatformName; + const char* BackendRendererName; + void* BackendPlatformUserData; + void* BackendRendererUserData; + void* BackendLanguageUserData; + const char* (*GetClipboardTextFn)(void* user_data); + void (*SetClipboardTextFn)(void* user_data, const char* text); + void* ClipboardUserData; + void (*ImeSetInputScreenPosFn)(int x, int y); + void* ImeWindowHandle; + void* RenderDrawListsFnUnused; + ImVec2 MousePos; + _Bool MouseDown[5]; + float MouseWheel; + float MouseWheelH; + _Bool KeyCtrl; + _Bool KeyShift; + _Bool KeyAlt; + _Bool KeySuper; + _Bool KeysDown[512]; + float NavInputs[ImGuiNavInput_COUNT]; + _Bool WantCaptureMouse; + _Bool WantCaptureKeyboard; + _Bool WantTextInput; + _Bool WantSetMousePos; + _Bool WantSaveIniSettings; + _Bool NavActive; + _Bool NavVisible; + float Framerate; + int MetricsRenderVertices; + int MetricsRenderIndices; + int MetricsRenderWindows; + int MetricsActiveWindows; + int MetricsActiveAllocations; + ImVec2 MouseDelta; + ImVec2 MousePosPrev; + ImVec2 MouseClickedPos[5]; + double MouseClickedTime[5]; + _Bool MouseClicked[5]; + _Bool MouseDoubleClicked[5]; + _Bool MouseReleased[5]; + _Bool MouseDownOwned[5]; + _Bool MouseDownWasDoubleClick[5]; + float MouseDownDuration[5]; + float MouseDownDurationPrev[5]; + ImVec2 MouseDragMaxDistanceAbs[5]; + float MouseDragMaxDistanceSqr[5]; + float KeysDownDuration[512]; + float KeysDownDurationPrev[512]; + float NavInputsDownDuration[ImGuiNavInput_COUNT]; + float NavInputsDownDurationPrev[ImGuiNavInput_COUNT]; + ImVector_ImWchar InputQueueCharacters; +}; +struct ImGuiInputTextCallbackData +{ + ImGuiInputTextFlags EventFlag; + ImGuiInputTextFlags Flags; + void* UserData; + ImWchar EventChar; + ImGuiKey EventKey; + char* Buf; + int BufTextLen; + int BufSize; + _Bool BufDirty; + int CursorPos; + int SelectionStart; + int SelectionEnd; +}; +struct ImGuiSizeCallbackData +{ + void* UserData; + ImVec2 Pos; + ImVec2 CurrentSize; + ImVec2 DesiredSize; +}; +struct ImGuiPayload +{ + void* Data; + int DataSize; + ImGuiID SourceId; + ImGuiID SourceParentId; + int DataFrameCount; + char DataType[32+1]; + _Bool Preview; + _Bool Delivery; +}; +struct ImGuiOnceUponAFrame +{ + int RefFrame; +}; +struct ImGuiTextFilter +{ + char InputBuf[256]; + ImVector_ImGuiTextRange Filters; + int CountGrep; +}; +struct ImGuiTextBuffer +{ + ImVector_char Buf; +}; +struct ImGuiStorage +{ + ImVector_ImGuiStoragePair Data; +}; +struct ImGuiListClipper +{ + float StartPosY; + float ItemsHeight; + int ItemsCount, StepNo, DisplayStart, DisplayEnd; +}; +struct ImColor +{ + ImVec4 Value; +}; +struct ImDrawCmd +{ + unsigned int ElemCount; + ImVec4 ClipRect; + ImTextureID TextureId; + unsigned int VtxOffset; + unsigned int IdxOffset; + ImDrawCallback UserCallback; + void* UserCallbackData; +}; +struct ImDrawVert +{ + ImVec2 pos; + ImVec2 uv; + ImU32 col; +}; +struct ImDrawChannel +{ + ImVector_ImDrawCmd _CmdBuffer; + ImVector_ImDrawIdx _IdxBuffer; +}; +struct ImDrawListSplitter +{ + int _Current; + int _Count; + ImVector_ImDrawChannel _Channels; +}; +enum ImDrawCornerFlags_ +{ + ImDrawCornerFlags_None = 0, + ImDrawCornerFlags_TopLeft = 1 << 0, + ImDrawCornerFlags_TopRight = 1 << 1, + ImDrawCornerFlags_BotLeft = 1 << 2, + ImDrawCornerFlags_BotRight = 1 << 3, + ImDrawCornerFlags_Top = ImDrawCornerFlags_TopLeft | ImDrawCornerFlags_TopRight, + ImDrawCornerFlags_Bot = ImDrawCornerFlags_BotLeft | ImDrawCornerFlags_BotRight, + ImDrawCornerFlags_Left = ImDrawCornerFlags_TopLeft | ImDrawCornerFlags_BotLeft, + ImDrawCornerFlags_Right = ImDrawCornerFlags_TopRight | ImDrawCornerFlags_BotRight, + ImDrawCornerFlags_All = 0xF +}; +enum ImDrawListFlags_ +{ + ImDrawListFlags_None = 0, + ImDrawListFlags_AntiAliasedLines = 1 << 0, + ImDrawListFlags_AntiAliasedFill = 1 << 1, + ImDrawListFlags_AllowVtxOffset = 1 << 2 +}; +struct ImDrawList +{ + ImVector_ImDrawCmd CmdBuffer; + ImVector_ImDrawIdx IdxBuffer; + ImVector_ImDrawVert VtxBuffer; + ImDrawListFlags Flags; + const ImDrawListSharedData* _Data; + const char* _OwnerName; + unsigned int _VtxCurrentOffset; + unsigned int _VtxCurrentIdx; + ImDrawVert* _VtxWritePtr; + ImDrawIdx* _IdxWritePtr; + ImVector_ImVec4 _ClipRectStack; + ImVector_ImTextureID _TextureIdStack; + ImVector_ImVec2 _Path; + ImDrawListSplitter _Splitter; +}; +struct ImDrawData +{ + _Bool Valid; + ImDrawList** CmdLists; + int CmdListsCount; + int TotalIdxCount; + int TotalVtxCount; + ImVec2 DisplayPos; + ImVec2 DisplaySize; + ImVec2 FramebufferScale; +}; +struct ImFontConfig +{ + void* FontData; + int FontDataSize; + _Bool FontDataOwnedByAtlas; + int FontNo; + float SizePixels; + int OversampleH; + int OversampleV; + _Bool PixelSnapH; + ImVec2 GlyphExtraSpacing; + ImVec2 GlyphOffset; + const ImWchar* GlyphRanges; + float GlyphMinAdvanceX; + float GlyphMaxAdvanceX; + _Bool MergeMode; + unsigned int RasterizerFlags; + float RasterizerMultiply; + char Name[40]; + ImFont* DstFont; +}; +struct ImFontGlyph +{ + ImWchar Codepoint; + float AdvanceX; + float X0, Y0, X1, Y1; + float U0, V0, U1, V1; +}; +struct ImFontGlyphRangesBuilder +{ + ImVector_ImU32 UsedChars; +}; +struct ImFontAtlasCustomRect +{ + unsigned int ID; + unsigned short Width, Height; + unsigned short X, Y; + float GlyphAdvanceX; + ImVec2 GlyphOffset; + ImFont* Font; +}; +enum ImFontAtlasFlags_ +{ + ImFontAtlasFlags_None = 0, + ImFontAtlasFlags_NoPowerOfTwoHeight = 1 << 0, + ImFontAtlasFlags_NoMouseCursors = 1 << 1 +}; +struct ImFontAtlas +{ + _Bool Locked; + ImFontAtlasFlags Flags; + ImTextureID TexID; + int TexDesiredWidth; + int TexGlyphPadding; + unsigned char* TexPixelsAlpha8; + unsigned int* TexPixelsRGBA32; + int TexWidth; + int TexHeight; + ImVec2 TexUvScale; + ImVec2 TexUvWhitePixel; + ImVector_ImFontPtr Fonts; + ImVector_ImFontAtlasCustomRect CustomRects; + ImVector_ImFontConfig ConfigData; + int CustomRectIds[1]; +}; +struct ImFont +{ + ImVector_float IndexAdvanceX; + float FallbackAdvanceX; + float FontSize; + ImVector_ImWchar IndexLookup; + ImVector_ImFontGlyph Glyphs; + const ImFontGlyph* FallbackGlyph; + ImVec2 DisplayOffset; + ImFontAtlas* ContainerAtlas; + const ImFontConfig* ConfigData; + short ConfigDataCount; + ImWchar FallbackChar; + float Scale; + float Ascent, Descent; + int MetricsTotalSurface; + _Bool DirtyLookupTables; +}; + struct ImGuiTextRange + { + const char* b; + const char* e; +}; + struct ImGuiStoragePair + { + ImGuiID key; + union { int val_i; float val_f; void* val_p; }; +}; +ImVec2* ImVec2_ImVec2(void); +void ImVec2_destroy(ImVec2* self); +ImVec2* ImVec2_ImVec2Float(float _x,float _y); +ImVec4* ImVec4_ImVec4(void); +void ImVec4_destroy(ImVec4* self); +ImVec4* ImVec4_ImVec4Float(float _x,float _y,float _z,float _w); +ImGuiContext* igCreateContext(ImFontAtlas* shared_font_atlas); +void igDestroyContext(ImGuiContext* ctx); +ImGuiContext* igGetCurrentContext(void); +void igSetCurrentContext(ImGuiContext* ctx); +_Bool igDebugCheckVersionAndDataLayout(const char* version_str,size_t sz_io,size_t sz_style,size_t sz_vec2,size_t sz_vec4,size_t sz_drawvert,size_t sz_drawidx); +ImGuiIO* igGetIO(void); +ImGuiStyle* igGetStyle(void); +void igNewFrame(void); +void igEndFrame(void); +void igRender(void); +ImDrawData* igGetDrawData(void); +void igShowDemoWindow( _Bool * p_open); +void igShowAboutWindow( _Bool * p_open); +void igShowMetricsWindow( _Bool * p_open); +void igShowStyleEditor(ImGuiStyle* ref); +_Bool igShowStyleSelector(const char* label); +void igShowFontSelector(const char* label); +void igShowUserGuide(void); +const char* igGetVersion(void); +void igStyleColorsDark(ImGuiStyle* dst); +void igStyleColorsClassic(ImGuiStyle* dst); +void igStyleColorsLight(ImGuiStyle* dst); +_Bool igBegin(const char* name, _Bool * p_open,ImGuiWindowFlags flags); +void igEnd(void); +_Bool igBeginChild(const char* str_id,const ImVec2 size, _Bool border,ImGuiWindowFlags flags); +_Bool igBeginChildID(ImGuiID id,const ImVec2 size, _Bool border,ImGuiWindowFlags flags); +void igEndChild(void); +_Bool igIsWindowAppearing(void); +_Bool igIsWindowCollapsed(void); +_Bool igIsWindowFocused(ImGuiFocusedFlags flags); +_Bool igIsWindowHovered(ImGuiHoveredFlags flags); +ImDrawList* igGetWindowDrawList(void); +ImVec2 igGetWindowPos(void); +ImVec2 igGetWindowSize(void); +float igGetWindowWidth(void); +float igGetWindowHeight(void); +void igSetNextWindowPos(const ImVec2 pos,ImGuiCond cond,const ImVec2 pivot); +void igSetNextWindowSize(const ImVec2 size,ImGuiCond cond); +void igSetNextWindowSizeConstraints(const ImVec2 size_min,const ImVec2 size_max,ImGuiSizeCallback custom_callback,void* custom_callback_data); +void igSetNextWindowContentSize(const ImVec2 size); +void igSetNextWindowCollapsed( _Bool collapsed,ImGuiCond cond); +void igSetNextWindowFocus(void); +void igSetNextWindowBgAlpha(float alpha); +void igSetWindowPosVec2(const ImVec2 pos,ImGuiCond cond); +void igSetWindowSizeVec2(const ImVec2 size,ImGuiCond cond); +void igSetWindowCollapsedBool( _Bool collapsed,ImGuiCond cond); +void igSetWindowFocus(void); +void igSetWindowFontScale(float scale); +void igSetWindowPosStr(const char* name,const ImVec2 pos,ImGuiCond cond); +void igSetWindowSizeStr(const char* name,const ImVec2 size,ImGuiCond cond); +void igSetWindowCollapsedStr(const char* name, _Bool collapsed,ImGuiCond cond); +void igSetWindowFocusStr(const char* name); +ImVec2 igGetContentRegionMax(void); +ImVec2 igGetContentRegionAvail(void); +ImVec2 igGetWindowContentRegionMin(void); +ImVec2 igGetWindowContentRegionMax(void); +float igGetWindowContentRegionWidth(void); +float igGetScrollX(void); +float igGetScrollY(void); +float igGetScrollMaxX(void); +float igGetScrollMaxY(void); +void igSetScrollX(float scroll_x); +void igSetScrollY(float scroll_y); +void igSetScrollHereX(float center_x_ratio); +void igSetScrollHereY(float center_y_ratio); +void igSetScrollFromPosX(float local_x,float center_x_ratio); +void igSetScrollFromPosY(float local_y,float center_y_ratio); +void igPushFont(ImFont* font); +void igPopFont(void); +void igPushStyleColorU32(ImGuiCol idx,ImU32 col); +void igPushStyleColor(ImGuiCol idx,const ImVec4 col); +void igPopStyleColor(int count); +void igPushStyleVarFloat(ImGuiStyleVar idx,float val); +void igPushStyleVarVec2(ImGuiStyleVar idx,const ImVec2 val); +void igPopStyleVar(int count); +const ImVec4* igGetStyleColorVec4(ImGuiCol idx); +ImFont* igGetFont(void); +float igGetFontSize(void); +ImVec2 igGetFontTexUvWhitePixel(void); +ImU32 igGetColorU32(ImGuiCol idx,float alpha_mul); +ImU32 igGetColorU32Vec4(const ImVec4 col); +ImU32 igGetColorU32U32(ImU32 col); +void igPushItemWidth(float item_width); +void igPopItemWidth(void); +void igSetNextItemWidth(float item_width); +float igCalcItemWidth(void); +void igPushTextWrapPos(float wrap_local_pos_x); +void igPopTextWrapPos(void); +void igPushAllowKeyboardFocus( _Bool allow_keyboard_focus); +void igPopAllowKeyboardFocus(void); +void igPushButtonRepeat( _Bool repeat); +void igPopButtonRepeat(void); +void igSeparator(void); +void igSameLine(float offset_from_start_x,float spacing); +void igNewLine(void); +void igSpacing(void); +void igDummy(const ImVec2 size); +void igIndent(float indent_w); +void igUnindent(float indent_w); +void igBeginGroup(void); +void igEndGroup(void); +ImVec2 igGetCursorPos(void); +float igGetCursorPosX(void); +float igGetCursorPosY(void); +void igSetCursorPos(const ImVec2 local_pos); +void igSetCursorPosX(float local_x); +void igSetCursorPosY(float local_y); +ImVec2 igGetCursorStartPos(void); +ImVec2 igGetCursorScreenPos(void); +void igSetCursorScreenPos(const ImVec2 pos); +void igAlignTextToFramePadding(void); +float igGetTextLineHeight(void); +float igGetTextLineHeightWithSpacing(void); +float igGetFrameHeight(void); +float igGetFrameHeightWithSpacing(void); +void igPushIDStr(const char* str_id); +void igPushIDRange(const char* str_id_begin,const char* str_id_end); +void igPushIDPtr(const void* ptr_id); +void igPushIDInt(int int_id); +void igPopID(void); +ImGuiID igGetIDStr(const char* str_id); +ImGuiID igGetIDRange(const char* str_id_begin,const char* str_id_end); +ImGuiID igGetIDPtr(const void* ptr_id); +void igTextUnformatted(const char* text,const char* text_end); +void igText(const char* fmt,...); +void igTextV(const char* fmt,va_list args); +void igTextColored(const ImVec4 col,const char* fmt,...); +void igTextColoredV(const ImVec4 col,const char* fmt,va_list args); +void igTextDisabled(const char* fmt,...); +void igTextDisabledV(const char* fmt,va_list args); +void igTextWrapped(const char* fmt,...); +void igTextWrappedV(const char* fmt,va_list args); +void igLabelText(const char* label,const char* fmt,...); +void igLabelTextV(const char* label,const char* fmt,va_list args); +void igBulletText(const char* fmt,...); +void igBulletTextV(const char* fmt,va_list args); +_Bool igButton(const char* label,const ImVec2 size); +_Bool igSmallButton(const char* label); +_Bool igInvisibleButton(const char* str_id,const ImVec2 size); +_Bool igArrowButton(const char* str_id,ImGuiDir dir); +void igImage(ImTextureID user_texture_id,const ImVec2 size,const ImVec2 uv0,const ImVec2 uv1,const ImVec4 tint_col,const ImVec4 border_col); +_Bool igImageButton(ImTextureID user_texture_id,const ImVec2 size,const ImVec2 uv0,const ImVec2 uv1,int frame_padding,const ImVec4 bg_col,const ImVec4 tint_col); +_Bool igCheckbox(const char* label, _Bool * v); +_Bool igCheckboxFlags(const char* label,unsigned int* flags,unsigned int flags_value); +_Bool igRadioButtonBool(const char* label, _Bool active); +_Bool igRadioButtonIntPtr(const char* label,int* v,int v_button); +void igProgressBar(float fraction,const ImVec2 size_arg,const char* overlay); +void igBullet(void); +_Bool igBeginCombo(const char* label,const char* preview_value,ImGuiComboFlags flags); +void igEndCombo(void); +_Bool igCombo(const char* label,int* current_item,const char* const items[],int items_count,int popup_max_height_in_items); +_Bool igComboStr(const char* label,int* current_item,const char* items_separated_by_zeros,int popup_max_height_in_items); +_Bool igComboFnPtr(const char* label,int* current_item, _Bool (*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int popup_max_height_in_items); +_Bool igDragFloat(const char* label,float* v,float v_speed,float v_min,float v_max,const char* format,float power); +_Bool igDragFloat2(const char* label,float v[2],float v_speed,float v_min,float v_max,const char* format,float power); +_Bool igDragFloat3(const char* label,float v[3],float v_speed,float v_min,float v_max,const char* format,float power); +_Bool igDragFloat4(const char* label,float v[4],float v_speed,float v_min,float v_max,const char* format,float power); +_Bool igDragFloatRange2(const char* label,float* v_current_min,float* v_current_max,float v_speed,float v_min,float v_max,const char* format,const char* format_max,float power); +_Bool igDragInt(const char* label,int* v,float v_speed,int v_min,int v_max,const char* format); +_Bool igDragInt2(const char* label,int v[2],float v_speed,int v_min,int v_max,const char* format); +_Bool igDragInt3(const char* label,int v[3],float v_speed,int v_min,int v_max,const char* format); +_Bool igDragInt4(const char* label,int v[4],float v_speed,int v_min,int v_max,const char* format); +_Bool igDragIntRange2(const char* label,int* v_current_min,int* v_current_max,float v_speed,int v_min,int v_max,const char* format,const char* format_max); +_Bool igDragScalar(const char* label,ImGuiDataType data_type,void* v,float v_speed,const void* v_min,const void* v_max,const char* format,float power); +_Bool igDragScalarN(const char* label,ImGuiDataType data_type,void* v,int components,float v_speed,const void* v_min,const void* v_max,const char* format,float power); +_Bool igSliderFloat(const char* label,float* v,float v_min,float v_max,const char* format,float power); +_Bool igSliderFloat2(const char* label,float v[2],float v_min,float v_max,const char* format,float power); +_Bool igSliderFloat3(const char* label,float v[3],float v_min,float v_max,const char* format,float power); +_Bool igSliderFloat4(const char* label,float v[4],float v_min,float v_max,const char* format,float power); +_Bool igSliderAngle(const char* label,float* v_rad,float v_degrees_min,float v_degrees_max,const char* format); +_Bool igSliderInt(const char* label,int* v,int v_min,int v_max,const char* format); +_Bool igSliderInt2(const char* label,int v[2],int v_min,int v_max,const char* format); +_Bool igSliderInt3(const char* label,int v[3],int v_min,int v_max,const char* format); +_Bool igSliderInt4(const char* label,int v[4],int v_min,int v_max,const char* format); +_Bool igSliderScalar(const char* label,ImGuiDataType data_type,void* v,const void* v_min,const void* v_max,const char* format,float power); +_Bool igSliderScalarN(const char* label,ImGuiDataType data_type,void* v,int components,const void* v_min,const void* v_max,const char* format,float power); +_Bool igVSliderFloat(const char* label,const ImVec2 size,float* v,float v_min,float v_max,const char* format,float power); +_Bool igVSliderInt(const char* label,const ImVec2 size,int* v,int v_min,int v_max,const char* format); +_Bool igVSliderScalar(const char* label,const ImVec2 size,ImGuiDataType data_type,void* v,const void* v_min,const void* v_max,const char* format,float power); +_Bool igInputText(const char* label,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data); +_Bool igInputTextMultiline(const char* label,char* buf,size_t buf_size,const ImVec2 size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data); +_Bool igInputTextWithHint(const char* label,const char* hint,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data); +_Bool igInputFloat(const char* label,float* v,float step,float step_fast,const char* format,ImGuiInputTextFlags flags); +_Bool igInputFloat2(const char* label,float v[2],const char* format,ImGuiInputTextFlags flags); +_Bool igInputFloat3(const char* label,float v[3],const char* format,ImGuiInputTextFlags flags); +_Bool igInputFloat4(const char* label,float v[4],const char* format,ImGuiInputTextFlags flags); +_Bool igInputInt(const char* label,int* v,int step,int step_fast,ImGuiInputTextFlags flags); +_Bool igInputInt2(const char* label,int v[2],ImGuiInputTextFlags flags); +_Bool igInputInt3(const char* label,int v[3],ImGuiInputTextFlags flags); +_Bool igInputInt4(const char* label,int v[4],ImGuiInputTextFlags flags); +_Bool igInputDouble(const char* label,double* v,double step,double step_fast,const char* format,ImGuiInputTextFlags flags); +_Bool igInputScalar(const char* label,ImGuiDataType data_type,void* v,const void* step,const void* step_fast,const char* format,ImGuiInputTextFlags flags); +_Bool igInputScalarN(const char* label,ImGuiDataType data_type,void* v,int components,const void* step,const void* step_fast,const char* format,ImGuiInputTextFlags flags); +_Bool igColorEdit3(const char* label,float col[3],ImGuiColorEditFlags flags); +_Bool igColorEdit4(const char* label,float col[4],ImGuiColorEditFlags flags); +_Bool igColorPicker3(const char* label,float col[3],ImGuiColorEditFlags flags); +_Bool igColorPicker4(const char* label,float col[4],ImGuiColorEditFlags flags,const float* ref_col); +_Bool igColorButton(const char* desc_id,const ImVec4 col,ImGuiColorEditFlags flags,ImVec2 size); +void igSetColorEditOptions(ImGuiColorEditFlags flags); +_Bool igTreeNodeStr(const char* label); +_Bool igTreeNodeStrStr(const char* str_id,const char* fmt,...); +_Bool igTreeNodePtr(const void* ptr_id,const char* fmt,...); +_Bool igTreeNodeVStr(const char* str_id,const char* fmt,va_list args); +_Bool igTreeNodeVPtr(const void* ptr_id,const char* fmt,va_list args); +_Bool igTreeNodeExStr(const char* label,ImGuiTreeNodeFlags flags); +_Bool igTreeNodeExStrStr(const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,...); +_Bool igTreeNodeExPtr(const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,...); +_Bool igTreeNodeExVStr(const char* str_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args); +_Bool igTreeNodeExVPtr(const void* ptr_id,ImGuiTreeNodeFlags flags,const char* fmt,va_list args); +void igTreePushStr(const char* str_id); +void igTreePushPtr(const void* ptr_id); +void igTreePop(void); +float igGetTreeNodeToLabelSpacing(void); +_Bool igCollapsingHeader(const char* label,ImGuiTreeNodeFlags flags); +_Bool igCollapsingHeaderBoolPtr(const char* label, _Bool * p_open,ImGuiTreeNodeFlags flags); +void igSetNextItemOpen( _Bool is_open,ImGuiCond cond); +_Bool igSelectable(const char* label, _Bool selected,ImGuiSelectableFlags flags,const ImVec2 size); +_Bool igSelectableBoolPtr(const char* label, _Bool * p_selected,ImGuiSelectableFlags flags,const ImVec2 size); +_Bool igListBoxStr_arr(const char* label,int* current_item,const char* const items[],int items_count,int height_in_items); +_Bool igListBoxFnPtr(const char* label,int* current_item, _Bool (*items_getter)(void* data,int idx,const char** out_text),void* data,int items_count,int height_in_items); +_Bool igListBoxHeaderVec2(const char* label,const ImVec2 size); +_Bool igListBoxHeaderInt(const char* label,int items_count,int height_in_items); +void igListBoxFooter(void); +void igPlotLines(const char* label,const float* values,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size,int stride); +void igPlotLinesFnPtr(const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size); +void igPlotHistogramFloatPtr(const char* label,const float* values,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size,int stride); +void igPlotHistogramFnPtr(const char* label,float(*values_getter)(void* data,int idx),void* data,int values_count,int values_offset,const char* overlay_text,float scale_min,float scale_max,ImVec2 graph_size); +void igValueBool(const char* prefix, _Bool b); +void igValueInt(const char* prefix,int v); +void igValueUint(const char* prefix,unsigned int v); +void igValueFloat(const char* prefix,float v,const char* float_format); +_Bool igBeginMainMenuBar(void); +void igEndMainMenuBar(void); +_Bool igBeginMenuBar(void); +void igEndMenuBar(void); +_Bool igBeginMenu(const char* label, _Bool enabled); +void igEndMenu(void); +_Bool igMenuItemBool(const char* label,const char* shortcut, _Bool selected, _Bool enabled); +_Bool igMenuItemBoolPtr(const char* label,const char* shortcut, _Bool * p_selected, _Bool enabled); +void igBeginTooltip(void); +void igEndTooltip(void); +void igSetTooltip(const char* fmt,...); +void igSetTooltipV(const char* fmt,va_list args); +void igOpenPopup(const char* str_id); +_Bool igBeginPopup(const char* str_id,ImGuiWindowFlags flags); +_Bool igBeginPopupContextItem(const char* str_id,int mouse_button); +_Bool igBeginPopupContextWindow(const char* str_id,int mouse_button, _Bool also_over_items); +_Bool igBeginPopupContextVoid(const char* str_id,int mouse_button); +_Bool igBeginPopupModal(const char* name, _Bool * p_open,ImGuiWindowFlags flags); +void igEndPopup(void); +_Bool igOpenPopupOnItemClick(const char* str_id,int mouse_button); +_Bool igIsPopupOpen(const char* str_id); +void igCloseCurrentPopup(void); +void igColumns(int count,const char* id, _Bool border); +void igNextColumn(void); +int igGetColumnIndex(void); +float igGetColumnWidth(int column_index); +void igSetColumnWidth(int column_index,float width); +float igGetColumnOffset(int column_index); +void igSetColumnOffset(int column_index,float offset_x); +int igGetColumnsCount(void); +_Bool igBeginTabBar(const char* str_id,ImGuiTabBarFlags flags); +void igEndTabBar(void); +_Bool igBeginTabItem(const char* label, _Bool * p_open,ImGuiTabItemFlags flags); +void igEndTabItem(void); +void igSetTabItemClosed(const char* tab_or_docked_window_label); +void igLogToTTY(int auto_open_depth); +void igLogToFile(int auto_open_depth,const char* filename); +void igLogToClipboard(int auto_open_depth); +void igLogFinish(void); +void igLogButtons(void); +_Bool igBeginDragDropSource(ImGuiDragDropFlags flags); +_Bool igSetDragDropPayload(const char* type,const void* data,size_t sz,ImGuiCond cond); +void igEndDragDropSource(void); +_Bool igBeginDragDropTarget(void); +const ImGuiPayload* igAcceptDragDropPayload(const char* type,ImGuiDragDropFlags flags); +void igEndDragDropTarget(void); +const ImGuiPayload* igGetDragDropPayload(void); +void igPushClipRect(const ImVec2 clip_rect_min,const ImVec2 clip_rect_max, _Bool intersect_with_current_clip_rect); +void igPopClipRect(void); +void igSetItemDefaultFocus(void); +void igSetKeyboardFocusHere(int offset); +_Bool igIsItemHovered(ImGuiHoveredFlags flags); +_Bool igIsItemActive(void); +_Bool igIsItemFocused(void); +_Bool igIsItemClicked(int mouse_button); +_Bool igIsItemVisible(void); +_Bool igIsItemEdited(void); +_Bool igIsItemActivated(void); +_Bool igIsItemDeactivated(void); +_Bool igIsItemDeactivatedAfterEdit(void); +_Bool igIsAnyItemHovered(void); +_Bool igIsAnyItemActive(void); +_Bool igIsAnyItemFocused(void); +ImVec2 igGetItemRectMin(void); +ImVec2 igGetItemRectMax(void); +ImVec2 igGetItemRectSize(void); +void igSetItemAllowOverlap(void); +_Bool igIsRectVisible(const ImVec2 size); +_Bool igIsRectVisibleVec2(const ImVec2 rect_min,const ImVec2 rect_max); +double igGetTime(void); +int igGetFrameCount(void); +ImDrawList* igGetBackgroundDrawList(void); +ImDrawList* igGetForegroundDrawList(void); +ImDrawListSharedData* igGetDrawListSharedData(void); +const char* igGetStyleColorName(ImGuiCol idx); +void igSetStateStorage(ImGuiStorage* storage); +ImGuiStorage* igGetStateStorage(void); +ImVec2 igCalcTextSize(const char* text,const char* text_end, _Bool hide_text_after_double_hash,float wrap_width); +void igCalcListClipping(int items_count,float items_height,int* out_items_display_start,int* out_items_display_end); +_Bool igBeginChildFrame(ImGuiID id,const ImVec2 size,ImGuiWindowFlags flags); +void igEndChildFrame(void); +ImVec4 igColorConvertU32ToFloat4(ImU32 in); +ImU32 igColorConvertFloat4ToU32(const ImVec4 in); +int igGetKeyIndex(ImGuiKey imgui_key); +_Bool igIsKeyDown(int user_key_index); +_Bool igIsKeyPressed(int user_key_index, _Bool repeat); +_Bool igIsKeyReleased(int user_key_index); +int igGetKeyPressedAmount(int key_index,float repeat_delay,float rate); +_Bool igIsMouseDown(int button); +_Bool igIsAnyMouseDown(void); +_Bool igIsMouseClicked(int button, _Bool repeat); +_Bool igIsMouseDoubleClicked(int button); +_Bool igIsMouseReleased(int button); +_Bool igIsMouseDragging(int button,float lock_threshold); +_Bool igIsMouseHoveringRect(const ImVec2 r_min,const ImVec2 r_max, _Bool clip); +_Bool igIsMousePosValid(const ImVec2* mouse_pos); +ImVec2 igGetMousePos(void); +ImVec2 igGetMousePosOnOpeningCurrentPopup(void); +ImVec2 igGetMouseDragDelta(int button,float lock_threshold); +void igResetMouseDragDelta(int button); +ImGuiMouseCursor igGetMouseCursor(void); +void igSetMouseCursor(ImGuiMouseCursor type); +void igCaptureKeyboardFromApp( _Bool want_capture_keyboard_value); +void igCaptureMouseFromApp( _Bool want_capture_mouse_value); +const char* igGetClipboardText(void); +void igSetClipboardText(const char* text); +void igLoadIniSettingsFromDisk(const char* ini_filename); +void igLoadIniSettingsFromMemory(const char* ini_data,size_t ini_size); +void igSaveIniSettingsToDisk(const char* ini_filename); +const char* igSaveIniSettingsToMemory(size_t* out_ini_size); +void igSetAllocatorFunctions(void*(*alloc_func)(size_t sz,void* user_data),void(*free_func)(void* ptr,void* user_data),void* user_data); +void* igMemAlloc(size_t size); +void igMemFree(void* ptr); +ImGuiStyle* ImGuiStyle_ImGuiStyle(void); +void ImGuiStyle_destroy(ImGuiStyle* self); +void ImGuiStyle_ScaleAllSizes(ImGuiStyle* self,float scale_factor); +void ImGuiIO_AddInputCharacter(ImGuiIO* self,unsigned int c); +void ImGuiIO_AddInputCharactersUTF8(ImGuiIO* self,const char* str); +void ImGuiIO_ClearInputCharacters(ImGuiIO* self); +ImGuiIO* ImGuiIO_ImGuiIO(void); +void ImGuiIO_destroy(ImGuiIO* self); +ImGuiInputTextCallbackData* ImGuiInputTextCallbackData_ImGuiInputTextCallbackData(void); +void ImGuiInputTextCallbackData_destroy(ImGuiInputTextCallbackData* self); +void ImGuiInputTextCallbackData_DeleteChars(ImGuiInputTextCallbackData* self,int pos,int bytes_count); +void ImGuiInputTextCallbackData_InsertChars(ImGuiInputTextCallbackData* self,int pos,const char* text,const char* text_end); +_Bool ImGuiInputTextCallbackData_HasSelection(ImGuiInputTextCallbackData* self); +ImGuiPayload* ImGuiPayload_ImGuiPayload(void); +void ImGuiPayload_destroy(ImGuiPayload* self); +void ImGuiPayload_Clear(ImGuiPayload* self); +_Bool ImGuiPayload_IsDataType(ImGuiPayload* self,const char* type); +_Bool ImGuiPayload_IsPreview(ImGuiPayload* self); +_Bool ImGuiPayload_IsDelivery(ImGuiPayload* self); +ImGuiOnceUponAFrame* ImGuiOnceUponAFrame_ImGuiOnceUponAFrame(void); +void ImGuiOnceUponAFrame_destroy(ImGuiOnceUponAFrame* self); +ImGuiTextFilter* ImGuiTextFilter_ImGuiTextFilter(const char* default_filter); +void ImGuiTextFilter_destroy(ImGuiTextFilter* self); +_Bool ImGuiTextFilter_Draw(ImGuiTextFilter* self,const char* label,float width); +_Bool ImGuiTextFilter_PassFilter(ImGuiTextFilter* self,const char* text,const char* text_end); +void ImGuiTextFilter_Build(ImGuiTextFilter* self); +void ImGuiTextFilter_Clear(ImGuiTextFilter* self); +_Bool ImGuiTextFilter_IsActive(ImGuiTextFilter* self); +ImGuiTextRange* ImGuiTextRange_ImGuiTextRange(void); +void ImGuiTextRange_destroy(ImGuiTextRange* self); +ImGuiTextRange* ImGuiTextRange_ImGuiTextRangeStr(const char* _b,const char* _e); +_Bool ImGuiTextRange_empty(ImGuiTextRange* self); +void ImGuiTextRange_split(ImGuiTextRange* self,char separator,ImVector_ImGuiTextRange* out); +ImGuiTextBuffer* ImGuiTextBuffer_ImGuiTextBuffer(void); +void ImGuiTextBuffer_destroy(ImGuiTextBuffer* self); +const char* ImGuiTextBuffer_begin(ImGuiTextBuffer* self); +const char* ImGuiTextBuffer_end(ImGuiTextBuffer* self); +int ImGuiTextBuffer_size(ImGuiTextBuffer* self); +_Bool ImGuiTextBuffer_empty(ImGuiTextBuffer* self); +void ImGuiTextBuffer_clear(ImGuiTextBuffer* self); +void ImGuiTextBuffer_reserve(ImGuiTextBuffer* self,int capacity); +const char* ImGuiTextBuffer_c_str(ImGuiTextBuffer* self); +void ImGuiTextBuffer_append(ImGuiTextBuffer* self,const char* str,const char* str_end); +void ImGuiTextBuffer_appendfv(ImGuiTextBuffer* self,const char* fmt,va_list args); +ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairInt(ImGuiID _key,int _val_i); +void ImGuiStoragePair_destroy(ImGuiStoragePair* self); +ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairFloat(ImGuiID _key,float _val_f); +ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairPtr(ImGuiID _key,void* _val_p); +void ImGuiStorage_Clear(ImGuiStorage* self); +int ImGuiStorage_GetInt(ImGuiStorage* self,ImGuiID key,int default_val); +void ImGuiStorage_SetInt(ImGuiStorage* self,ImGuiID key,int val); +_Bool ImGuiStorage_GetBool(ImGuiStorage* self,ImGuiID key, _Bool default_val); +void ImGuiStorage_SetBool(ImGuiStorage* self,ImGuiID key, _Bool val); +float ImGuiStorage_GetFloat(ImGuiStorage* self,ImGuiID key,float default_val); +void ImGuiStorage_SetFloat(ImGuiStorage* self,ImGuiID key,float val); +void* ImGuiStorage_GetVoidPtr(ImGuiStorage* self,ImGuiID key); +void ImGuiStorage_SetVoidPtr(ImGuiStorage* self,ImGuiID key,void* val); +int* ImGuiStorage_GetIntRef(ImGuiStorage* self,ImGuiID key,int default_val); +_Bool * ImGuiStorage_GetBoolRef(ImGuiStorage* self,ImGuiID key, _Bool default_val); +float* ImGuiStorage_GetFloatRef(ImGuiStorage* self,ImGuiID key,float default_val); +void** ImGuiStorage_GetVoidPtrRef(ImGuiStorage* self,ImGuiID key,void* default_val); +void ImGuiStorage_SetAllInt(ImGuiStorage* self,int val); +void ImGuiStorage_BuildSortByKey(ImGuiStorage* self); +ImGuiListClipper* ImGuiListClipper_ImGuiListClipper(int items_count,float items_height); +void ImGuiListClipper_destroy(ImGuiListClipper* self); +_Bool ImGuiListClipper_Step(ImGuiListClipper* self); +void ImGuiListClipper_Begin(ImGuiListClipper* self,int items_count,float items_height); +void ImGuiListClipper_End(ImGuiListClipper* self); +ImColor* ImColor_ImColor(void); +void ImColor_destroy(ImColor* self); +ImColor* ImColor_ImColorInt(int r,int g,int b,int a); +ImColor* ImColor_ImColorU32(ImU32 rgba); +ImColor* ImColor_ImColorFloat(float r,float g,float b,float a); +ImColor* ImColor_ImColorVec4(const ImVec4 col); +void ImColor_SetHSV(ImColor* self,float h,float s,float v,float a); +ImColor ImColor_HSV(ImColor* self,float h,float s,float v,float a); +ImDrawCmd* ImDrawCmd_ImDrawCmd(void); +void ImDrawCmd_destroy(ImDrawCmd* self); +ImDrawListSplitter* ImDrawListSplitter_ImDrawListSplitter(void); +void ImDrawListSplitter_destroy(ImDrawListSplitter* self); +void ImDrawListSplitter_Clear(ImDrawListSplitter* self); +void ImDrawListSplitter_ClearFreeMemory(ImDrawListSplitter* self); +void ImDrawListSplitter_Split(ImDrawListSplitter* self,ImDrawList* draw_list,int count); +void ImDrawListSplitter_Merge(ImDrawListSplitter* self,ImDrawList* draw_list); +void ImDrawListSplitter_SetCurrentChannel(ImDrawListSplitter* self,ImDrawList* draw_list,int channel_idx); +ImDrawList* ImDrawList_ImDrawList(const ImDrawListSharedData* shared_data); +void ImDrawList_destroy(ImDrawList* self); +void ImDrawList_PushClipRect(ImDrawList* self,ImVec2 clip_rect_min,ImVec2 clip_rect_max, _Bool intersect_with_current_clip_rect); +void ImDrawList_PushClipRectFullScreen(ImDrawList* self); +void ImDrawList_PopClipRect(ImDrawList* self); +void ImDrawList_PushTextureID(ImDrawList* self,ImTextureID texture_id); +void ImDrawList_PopTextureID(ImDrawList* self); +ImVec2 ImDrawList_GetClipRectMin(ImDrawList* self); +ImVec2 ImDrawList_GetClipRectMax(ImDrawList* self); +void ImDrawList_AddLine(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float thickness); +void ImDrawList_AddRect(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float rounding,ImDrawCornerFlags rounding_corners,float thickness); +void ImDrawList_AddRectFilled(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col,float rounding,ImDrawCornerFlags rounding_corners); +void ImDrawList_AddRectFilledMultiColor(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col_upr_left,ImU32 col_upr_right,ImU32 col_bot_right,ImU32 col_bot_left); +void ImDrawList_AddQuad(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,ImU32 col,float thickness); +void ImDrawList_AddQuadFilled(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,ImU32 col); +void ImDrawList_AddTriangle(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,ImU32 col,float thickness); +void ImDrawList_AddTriangleFilled(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,ImU32 col); +void ImDrawList_AddCircle(ImDrawList* self,const ImVec2 centre,float radius,ImU32 col,int num_segments,float thickness); +void ImDrawList_AddCircleFilled(ImDrawList* self,const ImVec2 centre,float radius,ImU32 col,int num_segments); +void ImDrawList_AddText(ImDrawList* self,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end); +void ImDrawList_AddTextFontPtr(ImDrawList* self,const ImFont* font,float font_size,const ImVec2 pos,ImU32 col,const char* text_begin,const char* text_end,float wrap_width,const ImVec4* cpu_fine_clip_rect); +void ImDrawList_AddImage(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col); +void ImDrawList_AddImageQuad(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,const ImVec2 uv_a,const ImVec2 uv_b,const ImVec2 uv_c,const ImVec2 uv_d,ImU32 col); +void ImDrawList_AddImageRounded(ImDrawList* self,ImTextureID user_texture_id,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col,float rounding,ImDrawCornerFlags rounding_corners); +void ImDrawList_AddPolyline(ImDrawList* self,const ImVec2* points,int num_points,ImU32 col, _Bool closed,float thickness); +void ImDrawList_AddConvexPolyFilled(ImDrawList* self,const ImVec2* points,int num_points,ImU32 col); +void ImDrawList_AddBezierCurve(ImDrawList* self,const ImVec2 pos0,const ImVec2 cp0,const ImVec2 cp1,const ImVec2 pos1,ImU32 col,float thickness,int num_segments); +void ImDrawList_PathClear(ImDrawList* self); +void ImDrawList_PathLineTo(ImDrawList* self,const ImVec2 pos); +void ImDrawList_PathLineToMergeDuplicate(ImDrawList* self,const ImVec2 pos); +void ImDrawList_PathFillConvex(ImDrawList* self,ImU32 col); +void ImDrawList_PathStroke(ImDrawList* self,ImU32 col, _Bool closed,float thickness); +void ImDrawList_PathArcTo(ImDrawList* self,const ImVec2 centre,float radius,float a_min,float a_max,int num_segments); +void ImDrawList_PathArcToFast(ImDrawList* self,const ImVec2 centre,float radius,int a_min_of_12,int a_max_of_12); +void ImDrawList_PathBezierCurveTo(ImDrawList* self,const ImVec2 p1,const ImVec2 p2,const ImVec2 p3,int num_segments); +void ImDrawList_PathRect(ImDrawList* self,const ImVec2 rect_min,const ImVec2 rect_max,float rounding,ImDrawCornerFlags rounding_corners); +void ImDrawList_AddCallback(ImDrawList* self,ImDrawCallback callback,void* callback_data); +void ImDrawList_AddDrawCmd(ImDrawList* self); +ImDrawList* ImDrawList_CloneOutput(ImDrawList* self); +void ImDrawList_ChannelsSplit(ImDrawList* self,int count); +void ImDrawList_ChannelsMerge(ImDrawList* self); +void ImDrawList_ChannelsSetCurrent(ImDrawList* self,int n); +void ImDrawList_Clear(ImDrawList* self); +void ImDrawList_ClearFreeMemory(ImDrawList* self); +void ImDrawList_PrimReserve(ImDrawList* self,int idx_count,int vtx_count); +void ImDrawList_PrimRect(ImDrawList* self,const ImVec2 a,const ImVec2 b,ImU32 col); +void ImDrawList_PrimRectUV(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 uv_a,const ImVec2 uv_b,ImU32 col); +void ImDrawList_PrimQuadUV(ImDrawList* self,const ImVec2 a,const ImVec2 b,const ImVec2 c,const ImVec2 d,const ImVec2 uv_a,const ImVec2 uv_b,const ImVec2 uv_c,const ImVec2 uv_d,ImU32 col); +void ImDrawList_PrimWriteVtx(ImDrawList* self,const ImVec2 pos,const ImVec2 uv,ImU32 col); +void ImDrawList_PrimWriteIdx(ImDrawList* self,ImDrawIdx idx); +void ImDrawList_PrimVtx(ImDrawList* self,const ImVec2 pos,const ImVec2 uv,ImU32 col); +void ImDrawList_UpdateClipRect(ImDrawList* self); +void ImDrawList_UpdateTextureID(ImDrawList* self); +ImDrawData* ImDrawData_ImDrawData(void); +void ImDrawData_destroy(ImDrawData* self); +void ImDrawData_Clear(ImDrawData* self); +void ImDrawData_DeIndexAllBuffers(ImDrawData* self); +void ImDrawData_ScaleClipRects(ImDrawData* self,const ImVec2 fb_scale); +ImFontConfig* ImFontConfig_ImFontConfig(void); +void ImFontConfig_destroy(ImFontConfig* self); +ImFontGlyphRangesBuilder* ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder(void); +void ImFontGlyphRangesBuilder_destroy(ImFontGlyphRangesBuilder* self); +void ImFontGlyphRangesBuilder_Clear(ImFontGlyphRangesBuilder* self); +_Bool ImFontGlyphRangesBuilder_GetBit(ImFontGlyphRangesBuilder* self,int n); +void ImFontGlyphRangesBuilder_SetBit(ImFontGlyphRangesBuilder* self,int n); +void ImFontGlyphRangesBuilder_AddChar(ImFontGlyphRangesBuilder* self,ImWchar c); +void ImFontGlyphRangesBuilder_AddText(ImFontGlyphRangesBuilder* self,const char* text,const char* text_end); +void ImFontGlyphRangesBuilder_AddRanges(ImFontGlyphRangesBuilder* self,const ImWchar* ranges); +void ImFontGlyphRangesBuilder_BuildRanges(ImFontGlyphRangesBuilder* self,ImVector_ImWchar* out_ranges); +ImFontAtlasCustomRect* ImFontAtlasCustomRect_ImFontAtlasCustomRect(void); +void ImFontAtlasCustomRect_destroy(ImFontAtlasCustomRect* self); +_Bool ImFontAtlasCustomRect_IsPacked(ImFontAtlasCustomRect* self); +ImFontAtlas* ImFontAtlas_ImFontAtlas(void); +void ImFontAtlas_destroy(ImFontAtlas* self); +ImFont* ImFontAtlas_AddFont(ImFontAtlas* self,const ImFontConfig* font_cfg); +ImFont* ImFontAtlas_AddFontDefault(ImFontAtlas* self,const ImFontConfig* font_cfg); +ImFont* ImFontAtlas_AddFontFromFileTTF(ImFontAtlas* self,const char* filename,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges); +ImFont* ImFontAtlas_AddFontFromMemoryTTF(ImFontAtlas* self,void* font_data,int font_size,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges); +ImFont* ImFontAtlas_AddFontFromMemoryCompressedTTF(ImFontAtlas* self,const void* compressed_font_data,int compressed_font_size,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges); +ImFont* ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(ImFontAtlas* self,const char* compressed_font_data_base85,float size_pixels,const ImFontConfig* font_cfg,const ImWchar* glyph_ranges); +void ImFontAtlas_ClearInputData(ImFontAtlas* self); +void ImFontAtlas_ClearTexData(ImFontAtlas* self); +void ImFontAtlas_ClearFonts(ImFontAtlas* self); +void ImFontAtlas_Clear(ImFontAtlas* self); +_Bool ImFontAtlas_Build(ImFontAtlas* self); +void ImFontAtlas_GetTexDataAsAlpha8(ImFontAtlas* self,unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel); +void ImFontAtlas_GetTexDataAsRGBA32(ImFontAtlas* self,unsigned char** out_pixels,int* out_width,int* out_height,int* out_bytes_per_pixel); +_Bool ImFontAtlas_IsBuilt(ImFontAtlas* self); +void ImFontAtlas_SetTexID(ImFontAtlas* self,ImTextureID id); +const ImWchar* ImFontAtlas_GetGlyphRangesDefault(ImFontAtlas* self); +const ImWchar* ImFontAtlas_GetGlyphRangesKorean(ImFontAtlas* self); +const ImWchar* ImFontAtlas_GetGlyphRangesJapanese(ImFontAtlas* self); +const ImWchar* ImFontAtlas_GetGlyphRangesChineseFull(ImFontAtlas* self); +const ImWchar* ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon(ImFontAtlas* self); +const ImWchar* ImFontAtlas_GetGlyphRangesCyrillic(ImFontAtlas* self); +const ImWchar* ImFontAtlas_GetGlyphRangesThai(ImFontAtlas* self); +const ImWchar* ImFontAtlas_GetGlyphRangesVietnamese(ImFontAtlas* self); +int ImFontAtlas_AddCustomRectRegular(ImFontAtlas* self,unsigned int id,int width,int height); +int ImFontAtlas_AddCustomRectFontGlyph(ImFontAtlas* self,ImFont* font,ImWchar id,int width,int height,float advance_x,const ImVec2 offset); +const ImFontAtlasCustomRect* ImFontAtlas_GetCustomRectByIndex(ImFontAtlas* self,int index); +void ImFontAtlas_CalcCustomRectUV(ImFontAtlas* self,const ImFontAtlasCustomRect* rect,ImVec2* out_uv_min,ImVec2* out_uv_max); +_Bool ImFontAtlas_GetMouseCursorTexData(ImFontAtlas* self,ImGuiMouseCursor cursor,ImVec2* out_offset,ImVec2* out_size,ImVec2 out_uv_border[2],ImVec2 out_uv_fill[2]); +ImFont* ImFont_ImFont(void); +void ImFont_destroy(ImFont* self); +const ImFontGlyph* ImFont_FindGlyph(ImFont* self,ImWchar c); +const ImFontGlyph* ImFont_FindGlyphNoFallback(ImFont* self,ImWchar c); +float ImFont_GetCharAdvance(ImFont* self,ImWchar c); +_Bool ImFont_IsLoaded(ImFont* self); +const char* ImFont_GetDebugName(ImFont* self); +ImVec2 ImFont_CalcTextSizeA(ImFont* self,float size,float max_width,float wrap_width,const char* text_begin,const char* text_end,const char** remaining); +const char* ImFont_CalcWordWrapPositionA(ImFont* self,float scale,const char* text,const char* text_end,float wrap_width); +void ImFont_RenderChar(ImFont* self,ImDrawList* draw_list,float size,ImVec2 pos,ImU32 col,ImWchar c); +void ImFont_RenderText(ImFont* self,ImDrawList* draw_list,float size,ImVec2 pos,ImU32 col,const ImVec4 clip_rect,const char* text_begin,const char* text_end,float wrap_width, _Bool cpu_fine_clip); +void ImFont_BuildLookupTable(ImFont* self); +void ImFont_ClearOutputData(ImFont* self); +void ImFont_GrowIndex(ImFont* self,int new_size); +void ImFont_AddGlyph(ImFont* self,ImWchar c,float x0,float y0,float x1,float y1,float u0,float v0,float u1,float v1,float advance_x); +void ImFont_AddRemapChar(ImFont* self,ImWchar dst,ImWchar src, _Bool overwrite_dst); +void ImFont_SetFallbackChar(ImFont* self,ImWchar c); +void igGetWindowPos_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetWindowPos_nonUDT2(void); +void igGetWindowSize_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetWindowSize_nonUDT2(void); +void igGetContentRegionMax_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetContentRegionMax_nonUDT2(void); +void igGetContentRegionAvail_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetContentRegionAvail_nonUDT2(void); +void igGetWindowContentRegionMin_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetWindowContentRegionMin_nonUDT2(void); +void igGetWindowContentRegionMax_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetWindowContentRegionMax_nonUDT2(void); +void igGetFontTexUvWhitePixel_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetFontTexUvWhitePixel_nonUDT2(void); +void igGetCursorPos_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetCursorPos_nonUDT2(void); +void igGetCursorStartPos_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetCursorStartPos_nonUDT2(void); +void igGetCursorScreenPos_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetCursorScreenPos_nonUDT2(void); +void igGetItemRectMin_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetItemRectMin_nonUDT2(void); +void igGetItemRectMax_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetItemRectMax_nonUDT2(void); +void igGetItemRectSize_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetItemRectSize_nonUDT2(void); +void igCalcTextSize_nonUDT(ImVec2 *pOut,const char* text,const char* text_end, _Bool hide_text_after_double_hash,float wrap_width); +ImVec2_Simple igCalcTextSize_nonUDT2(const char* text,const char* text_end, _Bool hide_text_after_double_hash,float wrap_width); +void igColorConvertU32ToFloat4_nonUDT(ImVec4 *pOut,ImU32 in); +ImVec4_Simple igColorConvertU32ToFloat4_nonUDT2(ImU32 in); +void igGetMousePos_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetMousePos_nonUDT2(void); +void igGetMousePosOnOpeningCurrentPopup_nonUDT(ImVec2 *pOut); +ImVec2_Simple igGetMousePosOnOpeningCurrentPopup_nonUDT2(void); +void igGetMouseDragDelta_nonUDT(ImVec2 *pOut,int button,float lock_threshold); +ImVec2_Simple igGetMouseDragDelta_nonUDT2(int button,float lock_threshold); +void ImColor_HSV_nonUDT(ImColor *pOut,ImColor* self,float h,float s,float v,float a); +ImColor_Simple ImColor_HSV_nonUDT2(ImColor* self,float h,float s,float v,float a); +void ImDrawList_GetClipRectMin_nonUDT(ImVec2 *pOut,ImDrawList* self); +ImVec2_Simple ImDrawList_GetClipRectMin_nonUDT2(ImDrawList* self); +void ImDrawList_GetClipRectMax_nonUDT(ImVec2 *pOut,ImDrawList* self); +ImVec2_Simple ImDrawList_GetClipRectMax_nonUDT2(ImDrawList* self); +void ImFont_CalcTextSizeA_nonUDT(ImVec2 *pOut,ImFont* self,float size,float max_width,float wrap_width,const char* text_begin,const char* text_end,const char** remaining); +ImVec2_Simple ImFont_CalcTextSizeA_nonUDT2(ImFont* self,float size,float max_width,float wrap_width,const char* text_begin,const char* text_end,const char** remaining); +ImVector_float* ImVector_float_ImVector_float(void); +void ImVector_float_destroy(ImVector_float* self); +ImVector_ImWchar* ImVector_ImWchar_ImVector_ImWchar(void); +void ImVector_ImWchar_destroy(ImVector_ImWchar* self); +ImVector_ImDrawVert* ImVector_ImDrawVert_ImVector_ImDrawVert(void); +void ImVector_ImDrawVert_destroy(ImVector_ImDrawVert* self); +ImVector_ImFontGlyph* ImVector_ImFontGlyph_ImVector_ImFontGlyph(void); +void ImVector_ImFontGlyph_destroy(ImVector_ImFontGlyph* self); +ImVector_ImGuiTextRange* ImVector_ImGuiTextRange_ImVector_ImGuiTextRange(void); +void ImVector_ImGuiTextRange_destroy(ImVector_ImGuiTextRange* self); +ImVector_ImGuiStoragePair* ImVector_ImGuiStoragePair_ImVector_ImGuiStoragePair(void); +void ImVector_ImGuiStoragePair_destroy(ImVector_ImGuiStoragePair* self); +ImVector_ImDrawChannel* ImVector_ImDrawChannel_ImVector_ImDrawChannel(void); +void ImVector_ImDrawChannel_destroy(ImVector_ImDrawChannel* self); +ImVector_char* ImVector_char_ImVector_char(void); +void ImVector_char_destroy(ImVector_char* self); +ImVector_ImU32* ImVector_ImU32_ImVector_ImU32(void); +void ImVector_ImU32_destroy(ImVector_ImU32* self); +ImVector_ImFontAtlasCustomRect* ImVector_ImFontAtlasCustomRect_ImVector_ImFontAtlasCustomRect(void); +void ImVector_ImFontAtlasCustomRect_destroy(ImVector_ImFontAtlasCustomRect* self); +ImVector_ImTextureID* ImVector_ImTextureID_ImVector_ImTextureID(void); +void ImVector_ImTextureID_destroy(ImVector_ImTextureID* self); +ImVector_ImFontConfig* ImVector_ImFontConfig_ImVector_ImFontConfig(void); +void ImVector_ImFontConfig_destroy(ImVector_ImFontConfig* self); +ImVector_ImFontPtr* ImVector_ImFontPtr_ImVector_ImFontPtr(void); +void ImVector_ImFontPtr_destroy(ImVector_ImFontPtr* self); +ImVector_ImDrawCmd* ImVector_ImDrawCmd_ImVector_ImDrawCmd(void); +void ImVector_ImDrawCmd_destroy(ImVector_ImDrawCmd* self); +ImVector_ImVec4* ImVector_ImVec4_ImVector_ImVec4(void); +void ImVector_ImVec4_destroy(ImVector_ImVec4* self); +ImVector_ImDrawIdx* ImVector_ImDrawIdx_ImVector_ImDrawIdx(void); +void ImVector_ImDrawIdx_destroy(ImVector_ImDrawIdx* self); +ImVector_ImVec2* ImVector_ImVec2_ImVector_ImVec2(void); +void ImVector_ImVec2_destroy(ImVector_ImVec2* self); +ImVector_float* ImVector_float_ImVector_floatVector(const ImVector_float src); +ImVector_ImWchar* ImVector_ImWchar_ImVector_ImWcharVector(const ImVector_ImWchar src); +ImVector_ImDrawVert* ImVector_ImDrawVert_ImVector_ImDrawVertVector(const ImVector_ImDrawVert src); +ImVector_ImFontGlyph* ImVector_ImFontGlyph_ImVector_ImFontGlyphVector(const ImVector_ImFontGlyph src); +ImVector_ImGuiTextRange* ImVector_ImGuiTextRange_ImVector_ImGuiTextRangeVector(const ImVector_ImGuiTextRange src); +ImVector_ImGuiStoragePair* ImVector_ImGuiStoragePair_ImVector_ImGuiStoragePairVector(const ImVector_ImGuiStoragePair src); +ImVector_ImDrawChannel* ImVector_ImDrawChannel_ImVector_ImDrawChannelVector(const ImVector_ImDrawChannel src); +ImVector_char* ImVector_char_ImVector_charVector(const ImVector_char src); +ImVector_ImU32* ImVector_ImU32_ImVector_ImU32Vector(const ImVector_ImU32 src); +ImVector_ImFontAtlasCustomRect* ImVector_ImFontAtlasCustomRect_ImVector_ImFontAtlasCustomRectVector(const ImVector_ImFontAtlasCustomRect src); +ImVector_ImTextureID* ImVector_ImTextureID_ImVector_ImTextureIDVector(const ImVector_ImTextureID src); +ImVector_ImFontConfig* ImVector_ImFontConfig_ImVector_ImFontConfigVector(const ImVector_ImFontConfig src); +ImVector_ImFontPtr* ImVector_ImFontPtr_ImVector_ImFontPtrVector(const ImVector_ImFontPtr src); +ImVector_ImDrawCmd* ImVector_ImDrawCmd_ImVector_ImDrawCmdVector(const ImVector_ImDrawCmd src); +ImVector_ImVec4* ImVector_ImVec4_ImVector_ImVec4Vector(const ImVector_ImVec4 src); +ImVector_ImDrawIdx* ImVector_ImDrawIdx_ImVector_ImDrawIdxVector(const ImVector_ImDrawIdx src); +ImVector_ImVec2* ImVector_ImVec2_ImVector_ImVec2Vector(const ImVector_ImVec2 src); +_Bool ImVector_float_empty(const ImVector_float* self); +_Bool ImVector_ImWchar_empty(const ImVector_ImWchar* self); +_Bool ImVector_ImDrawVert_empty(const ImVector_ImDrawVert* self); +_Bool ImVector_ImFontGlyph_empty(const ImVector_ImFontGlyph* self); +_Bool ImVector_ImGuiTextRange_empty(const ImVector_ImGuiTextRange* self); +_Bool ImVector_ImGuiStoragePair_empty(const ImVector_ImGuiStoragePair* self); +_Bool ImVector_ImDrawChannel_empty(const ImVector_ImDrawChannel* self); +_Bool ImVector_char_empty(const ImVector_char* self); +_Bool ImVector_ImU32_empty(const ImVector_ImU32* self); +_Bool ImVector_ImFontAtlasCustomRect_empty(const ImVector_ImFontAtlasCustomRect* self); +_Bool ImVector_ImTextureID_empty(const ImVector_ImTextureID* self); +_Bool ImVector_ImFontConfig_empty(const ImVector_ImFontConfig* self); +_Bool ImVector_ImFontPtr_empty(const ImVector_ImFontPtr* self); +_Bool ImVector_ImDrawCmd_empty(const ImVector_ImDrawCmd* self); +_Bool ImVector_ImVec4_empty(const ImVector_ImVec4* self); +_Bool ImVector_ImDrawIdx_empty(const ImVector_ImDrawIdx* self); +_Bool ImVector_ImVec2_empty(const ImVector_ImVec2* self); +int ImVector_float_size(const ImVector_float* self); +int ImVector_ImWchar_size(const ImVector_ImWchar* self); +int ImVector_ImDrawVert_size(const ImVector_ImDrawVert* self); +int ImVector_ImFontGlyph_size(const ImVector_ImFontGlyph* self); +int ImVector_ImGuiTextRange_size(const ImVector_ImGuiTextRange* self); +int ImVector_ImGuiStoragePair_size(const ImVector_ImGuiStoragePair* self); +int ImVector_ImDrawChannel_size(const ImVector_ImDrawChannel* self); +int ImVector_char_size(const ImVector_char* self); +int ImVector_ImU32_size(const ImVector_ImU32* self); +int ImVector_ImFontAtlasCustomRect_size(const ImVector_ImFontAtlasCustomRect* self); +int ImVector_ImTextureID_size(const ImVector_ImTextureID* self); +int ImVector_ImFontConfig_size(const ImVector_ImFontConfig* self); +int ImVector_ImFontPtr_size(const ImVector_ImFontPtr* self); +int ImVector_ImDrawCmd_size(const ImVector_ImDrawCmd* self); +int ImVector_ImVec4_size(const ImVector_ImVec4* self); +int ImVector_ImDrawIdx_size(const ImVector_ImDrawIdx* self); +int ImVector_ImVec2_size(const ImVector_ImVec2* self); +int ImVector_float_size_in_bytes(const ImVector_float* self); +int ImVector_ImWchar_size_in_bytes(const ImVector_ImWchar* self); +int ImVector_ImDrawVert_size_in_bytes(const ImVector_ImDrawVert* self); +int ImVector_ImFontGlyph_size_in_bytes(const ImVector_ImFontGlyph* self); +int ImVector_ImGuiTextRange_size_in_bytes(const ImVector_ImGuiTextRange* self); +int ImVector_ImGuiStoragePair_size_in_bytes(const ImVector_ImGuiStoragePair* self); +int ImVector_ImDrawChannel_size_in_bytes(const ImVector_ImDrawChannel* self); +int ImVector_char_size_in_bytes(const ImVector_char* self); +int ImVector_ImU32_size_in_bytes(const ImVector_ImU32* self); +int ImVector_ImFontAtlasCustomRect_size_in_bytes(const ImVector_ImFontAtlasCustomRect* self); +int ImVector_ImTextureID_size_in_bytes(const ImVector_ImTextureID* self); +int ImVector_ImFontConfig_size_in_bytes(const ImVector_ImFontConfig* self); +int ImVector_ImFontPtr_size_in_bytes(const ImVector_ImFontPtr* self); +int ImVector_ImDrawCmd_size_in_bytes(const ImVector_ImDrawCmd* self); +int ImVector_ImVec4_size_in_bytes(const ImVector_ImVec4* self); +int ImVector_ImDrawIdx_size_in_bytes(const ImVector_ImDrawIdx* self); +int ImVector_ImVec2_size_in_bytes(const ImVector_ImVec2* self); +int ImVector_float_capacity(const ImVector_float* self); +int ImVector_ImWchar_capacity(const ImVector_ImWchar* self); +int ImVector_ImDrawVert_capacity(const ImVector_ImDrawVert* self); +int ImVector_ImFontGlyph_capacity(const ImVector_ImFontGlyph* self); +int ImVector_ImGuiTextRange_capacity(const ImVector_ImGuiTextRange* self); +int ImVector_ImGuiStoragePair_capacity(const ImVector_ImGuiStoragePair* self); +int ImVector_ImDrawChannel_capacity(const ImVector_ImDrawChannel* self); +int ImVector_char_capacity(const ImVector_char* self); +int ImVector_ImU32_capacity(const ImVector_ImU32* self); +int ImVector_ImFontAtlasCustomRect_capacity(const ImVector_ImFontAtlasCustomRect* self); +int ImVector_ImTextureID_capacity(const ImVector_ImTextureID* self); +int ImVector_ImFontConfig_capacity(const ImVector_ImFontConfig* self); +int ImVector_ImFontPtr_capacity(const ImVector_ImFontPtr* self); +int ImVector_ImDrawCmd_capacity(const ImVector_ImDrawCmd* self); +int ImVector_ImVec4_capacity(const ImVector_ImVec4* self); +int ImVector_ImDrawIdx_capacity(const ImVector_ImDrawIdx* self); +int ImVector_ImVec2_capacity(const ImVector_ImVec2* self); +void ImVector_float_clear(ImVector_float* self); +void ImVector_ImWchar_clear(ImVector_ImWchar* self); +void ImVector_ImDrawVert_clear(ImVector_ImDrawVert* self); +void ImVector_ImFontGlyph_clear(ImVector_ImFontGlyph* self); +void ImVector_ImGuiTextRange_clear(ImVector_ImGuiTextRange* self); +void ImVector_ImGuiStoragePair_clear(ImVector_ImGuiStoragePair* self); +void ImVector_ImDrawChannel_clear(ImVector_ImDrawChannel* self); +void ImVector_char_clear(ImVector_char* self); +void ImVector_ImU32_clear(ImVector_ImU32* self); +void ImVector_ImFontAtlasCustomRect_clear(ImVector_ImFontAtlasCustomRect* self); +void ImVector_ImTextureID_clear(ImVector_ImTextureID* self); +void ImVector_ImFontConfig_clear(ImVector_ImFontConfig* self); +void ImVector_ImFontPtr_clear(ImVector_ImFontPtr* self); +void ImVector_ImDrawCmd_clear(ImVector_ImDrawCmd* self); +void ImVector_ImVec4_clear(ImVector_ImVec4* self); +void ImVector_ImDrawIdx_clear(ImVector_ImDrawIdx* self); +void ImVector_ImVec2_clear(ImVector_ImVec2* self); +float* ImVector_float_begin(ImVector_float* self); +ImWchar* ImVector_ImWchar_begin(ImVector_ImWchar* self); +ImDrawVert* ImVector_ImDrawVert_begin(ImVector_ImDrawVert* self); +ImFontGlyph* ImVector_ImFontGlyph_begin(ImVector_ImFontGlyph* self); +ImGuiTextRange* ImVector_ImGuiTextRange_begin(ImVector_ImGuiTextRange* self); +ImGuiStoragePair* ImVector_ImGuiStoragePair_begin(ImVector_ImGuiStoragePair* self); +ImDrawChannel* ImVector_ImDrawChannel_begin(ImVector_ImDrawChannel* self); +char* ImVector_char_begin(ImVector_char* self); +ImU32* ImVector_ImU32_begin(ImVector_ImU32* self); +ImFontAtlasCustomRect* ImVector_ImFontAtlasCustomRect_begin(ImVector_ImFontAtlasCustomRect* self); +ImTextureID* ImVector_ImTextureID_begin(ImVector_ImTextureID* self); +ImFontConfig* ImVector_ImFontConfig_begin(ImVector_ImFontConfig* self); +ImFont** ImVector_ImFontPtr_begin(ImVector_ImFontPtr* self); +ImDrawCmd* ImVector_ImDrawCmd_begin(ImVector_ImDrawCmd* self); +ImVec4* ImVector_ImVec4_begin(ImVector_ImVec4* self); +ImDrawIdx* ImVector_ImDrawIdx_begin(ImVector_ImDrawIdx* self); +ImVec2* ImVector_ImVec2_begin(ImVector_ImVec2* self); +float const * ImVector_float_begin_const(const ImVector_float* self); +ImWchar const * ImVector_ImWchar_begin_const(const ImVector_ImWchar* self); +ImDrawVert const * ImVector_ImDrawVert_begin_const(const ImVector_ImDrawVert* self); +ImFontGlyph const * ImVector_ImFontGlyph_begin_const(const ImVector_ImFontGlyph* self); +ImGuiTextRange const * ImVector_ImGuiTextRange_begin_const(const ImVector_ImGuiTextRange* self); +ImGuiStoragePair const * ImVector_ImGuiStoragePair_begin_const(const ImVector_ImGuiStoragePair* self); +ImDrawChannel const * ImVector_ImDrawChannel_begin_const(const ImVector_ImDrawChannel* self); +char const * ImVector_char_begin_const(const ImVector_char* self); +ImU32 const * ImVector_ImU32_begin_const(const ImVector_ImU32* self); +ImFontAtlasCustomRect const * ImVector_ImFontAtlasCustomRect_begin_const(const ImVector_ImFontAtlasCustomRect* self); +ImTextureID const * ImVector_ImTextureID_begin_const(const ImVector_ImTextureID* self); +ImFontConfig const * ImVector_ImFontConfig_begin_const(const ImVector_ImFontConfig* self); +ImFont* const * ImVector_ImFontPtr_begin_const(const ImVector_ImFontPtr* self); +ImDrawCmd const * ImVector_ImDrawCmd_begin_const(const ImVector_ImDrawCmd* self); +ImVec4 const * ImVector_ImVec4_begin_const(const ImVector_ImVec4* self); +ImDrawIdx const * ImVector_ImDrawIdx_begin_const(const ImVector_ImDrawIdx* self); +ImVec2 const * ImVector_ImVec2_begin_const(const ImVector_ImVec2* self); +float* ImVector_float_end(ImVector_float* self); +ImWchar* ImVector_ImWchar_end(ImVector_ImWchar* self); +ImDrawVert* ImVector_ImDrawVert_end(ImVector_ImDrawVert* self); +ImFontGlyph* ImVector_ImFontGlyph_end(ImVector_ImFontGlyph* self); +ImGuiTextRange* ImVector_ImGuiTextRange_end(ImVector_ImGuiTextRange* self); +ImGuiStoragePair* ImVector_ImGuiStoragePair_end(ImVector_ImGuiStoragePair* self); +ImDrawChannel* ImVector_ImDrawChannel_end(ImVector_ImDrawChannel* self); +char* ImVector_char_end(ImVector_char* self); +ImU32* ImVector_ImU32_end(ImVector_ImU32* self); +ImFontAtlasCustomRect* ImVector_ImFontAtlasCustomRect_end(ImVector_ImFontAtlasCustomRect* self); +ImTextureID* ImVector_ImTextureID_end(ImVector_ImTextureID* self); +ImFontConfig* ImVector_ImFontConfig_end(ImVector_ImFontConfig* self); +ImFont** ImVector_ImFontPtr_end(ImVector_ImFontPtr* self); +ImDrawCmd* ImVector_ImDrawCmd_end(ImVector_ImDrawCmd* self); +ImVec4* ImVector_ImVec4_end(ImVector_ImVec4* self); +ImDrawIdx* ImVector_ImDrawIdx_end(ImVector_ImDrawIdx* self); +ImVec2* ImVector_ImVec2_end(ImVector_ImVec2* self); +float const * ImVector_float_end_const(const ImVector_float* self); +ImWchar const * ImVector_ImWchar_end_const(const ImVector_ImWchar* self); +ImDrawVert const * ImVector_ImDrawVert_end_const(const ImVector_ImDrawVert* self); +ImFontGlyph const * ImVector_ImFontGlyph_end_const(const ImVector_ImFontGlyph* self); +ImGuiTextRange const * ImVector_ImGuiTextRange_end_const(const ImVector_ImGuiTextRange* self); +ImGuiStoragePair const * ImVector_ImGuiStoragePair_end_const(const ImVector_ImGuiStoragePair* self); +ImDrawChannel const * ImVector_ImDrawChannel_end_const(const ImVector_ImDrawChannel* self); +char const * ImVector_char_end_const(const ImVector_char* self); +ImU32 const * ImVector_ImU32_end_const(const ImVector_ImU32* self); +ImFontAtlasCustomRect const * ImVector_ImFontAtlasCustomRect_end_const(const ImVector_ImFontAtlasCustomRect* self); +ImTextureID const * ImVector_ImTextureID_end_const(const ImVector_ImTextureID* self); +ImFontConfig const * ImVector_ImFontConfig_end_const(const ImVector_ImFontConfig* self); +ImFont* const * ImVector_ImFontPtr_end_const(const ImVector_ImFontPtr* self); +ImDrawCmd const * ImVector_ImDrawCmd_end_const(const ImVector_ImDrawCmd* self); +ImVec4 const * ImVector_ImVec4_end_const(const ImVector_ImVec4* self); +ImDrawIdx const * ImVector_ImDrawIdx_end_const(const ImVector_ImDrawIdx* self); +ImVec2 const * ImVector_ImVec2_end_const(const ImVector_ImVec2* self); +float* ImVector_float_front(ImVector_float* self); +ImWchar* ImVector_ImWchar_front(ImVector_ImWchar* self); +ImDrawVert* ImVector_ImDrawVert_front(ImVector_ImDrawVert* self); +ImFontGlyph* ImVector_ImFontGlyph_front(ImVector_ImFontGlyph* self); +ImGuiTextRange* ImVector_ImGuiTextRange_front(ImVector_ImGuiTextRange* self); +ImGuiStoragePair* ImVector_ImGuiStoragePair_front(ImVector_ImGuiStoragePair* self); +ImDrawChannel* ImVector_ImDrawChannel_front(ImVector_ImDrawChannel* self); +char* ImVector_char_front(ImVector_char* self); +ImU32* ImVector_ImU32_front(ImVector_ImU32* self); +ImFontAtlasCustomRect* ImVector_ImFontAtlasCustomRect_front(ImVector_ImFontAtlasCustomRect* self); +ImTextureID* ImVector_ImTextureID_front(ImVector_ImTextureID* self); +ImFontConfig* ImVector_ImFontConfig_front(ImVector_ImFontConfig* self); +ImFont** ImVector_ImFontPtr_front(ImVector_ImFontPtr* self); +ImDrawCmd* ImVector_ImDrawCmd_front(ImVector_ImDrawCmd* self); +ImVec4* ImVector_ImVec4_front(ImVector_ImVec4* self); +ImDrawIdx* ImVector_ImDrawIdx_front(ImVector_ImDrawIdx* self); +ImVec2* ImVector_ImVec2_front(ImVector_ImVec2* self); +float const * ImVector_float_front_const(const ImVector_float* self); +ImWchar const * ImVector_ImWchar_front_const(const ImVector_ImWchar* self); +ImDrawVert const * ImVector_ImDrawVert_front_const(const ImVector_ImDrawVert* self); +ImFontGlyph const * ImVector_ImFontGlyph_front_const(const ImVector_ImFontGlyph* self); +ImGuiTextRange const * ImVector_ImGuiTextRange_front_const(const ImVector_ImGuiTextRange* self); +ImGuiStoragePair const * ImVector_ImGuiStoragePair_front_const(const ImVector_ImGuiStoragePair* self); +ImDrawChannel const * ImVector_ImDrawChannel_front_const(const ImVector_ImDrawChannel* self); +char const * ImVector_char_front_const(const ImVector_char* self); +ImU32 const * ImVector_ImU32_front_const(const ImVector_ImU32* self); +ImFontAtlasCustomRect const * ImVector_ImFontAtlasCustomRect_front_const(const ImVector_ImFontAtlasCustomRect* self); +ImTextureID const * ImVector_ImTextureID_front_const(const ImVector_ImTextureID* self); +ImFontConfig const * ImVector_ImFontConfig_front_const(const ImVector_ImFontConfig* self); +ImFont* const * ImVector_ImFontPtr_front_const(const ImVector_ImFontPtr* self); +ImDrawCmd const * ImVector_ImDrawCmd_front_const(const ImVector_ImDrawCmd* self); +ImVec4 const * ImVector_ImVec4_front_const(const ImVector_ImVec4* self); +ImDrawIdx const * ImVector_ImDrawIdx_front_const(const ImVector_ImDrawIdx* self); +ImVec2 const * ImVector_ImVec2_front_const(const ImVector_ImVec2* self); +float* ImVector_float_back(ImVector_float* self); +ImWchar* ImVector_ImWchar_back(ImVector_ImWchar* self); +ImDrawVert* ImVector_ImDrawVert_back(ImVector_ImDrawVert* self); +ImFontGlyph* ImVector_ImFontGlyph_back(ImVector_ImFontGlyph* self); +ImGuiTextRange* ImVector_ImGuiTextRange_back(ImVector_ImGuiTextRange* self); +ImGuiStoragePair* ImVector_ImGuiStoragePair_back(ImVector_ImGuiStoragePair* self); +ImDrawChannel* ImVector_ImDrawChannel_back(ImVector_ImDrawChannel* self); +char* ImVector_char_back(ImVector_char* self); +ImU32* ImVector_ImU32_back(ImVector_ImU32* self); +ImFontAtlasCustomRect* ImVector_ImFontAtlasCustomRect_back(ImVector_ImFontAtlasCustomRect* self); +ImTextureID* ImVector_ImTextureID_back(ImVector_ImTextureID* self); +ImFontConfig* ImVector_ImFontConfig_back(ImVector_ImFontConfig* self); +ImFont** ImVector_ImFontPtr_back(ImVector_ImFontPtr* self); +ImDrawCmd* ImVector_ImDrawCmd_back(ImVector_ImDrawCmd* self); +ImVec4* ImVector_ImVec4_back(ImVector_ImVec4* self); +ImDrawIdx* ImVector_ImDrawIdx_back(ImVector_ImDrawIdx* self); +ImVec2* ImVector_ImVec2_back(ImVector_ImVec2* self); +float const * ImVector_float_back_const(const ImVector_float* self); +ImWchar const * ImVector_ImWchar_back_const(const ImVector_ImWchar* self); +ImDrawVert const * ImVector_ImDrawVert_back_const(const ImVector_ImDrawVert* self); +ImFontGlyph const * ImVector_ImFontGlyph_back_const(const ImVector_ImFontGlyph* self); +ImGuiTextRange const * ImVector_ImGuiTextRange_back_const(const ImVector_ImGuiTextRange* self); +ImGuiStoragePair const * ImVector_ImGuiStoragePair_back_const(const ImVector_ImGuiStoragePair* self); +ImDrawChannel const * ImVector_ImDrawChannel_back_const(const ImVector_ImDrawChannel* self); +char const * ImVector_char_back_const(const ImVector_char* self); +ImU32 const * ImVector_ImU32_back_const(const ImVector_ImU32* self); +ImFontAtlasCustomRect const * ImVector_ImFontAtlasCustomRect_back_const(const ImVector_ImFontAtlasCustomRect* self); +ImTextureID const * ImVector_ImTextureID_back_const(const ImVector_ImTextureID* self); +ImFontConfig const * ImVector_ImFontConfig_back_const(const ImVector_ImFontConfig* self); +ImFont* const * ImVector_ImFontPtr_back_const(const ImVector_ImFontPtr* self); +ImDrawCmd const * ImVector_ImDrawCmd_back_const(const ImVector_ImDrawCmd* self); +ImVec4 const * ImVector_ImVec4_back_const(const ImVector_ImVec4* self); +ImDrawIdx const * ImVector_ImDrawIdx_back_const(const ImVector_ImDrawIdx* self); +ImVec2 const * ImVector_ImVec2_back_const(const ImVector_ImVec2* self); +void ImVector_float_swap(ImVector_float* self,ImVector_float rhs); +void ImVector_ImWchar_swap(ImVector_ImWchar* self,ImVector_ImWchar rhs); +void ImVector_ImDrawVert_swap(ImVector_ImDrawVert* self,ImVector_ImDrawVert rhs); +void ImVector_ImFontGlyph_swap(ImVector_ImFontGlyph* self,ImVector_ImFontGlyph rhs); +void ImVector_ImGuiTextRange_swap(ImVector_ImGuiTextRange* self,ImVector_ImGuiTextRange rhs); +void ImVector_ImGuiStoragePair_swap(ImVector_ImGuiStoragePair* self,ImVector_ImGuiStoragePair rhs); +void ImVector_ImDrawChannel_swap(ImVector_ImDrawChannel* self,ImVector_ImDrawChannel rhs); +void ImVector_char_swap(ImVector_char* self,ImVector_char rhs); +void ImVector_ImU32_swap(ImVector_ImU32* self,ImVector_ImU32 rhs); +void ImVector_ImFontAtlasCustomRect_swap(ImVector_ImFontAtlasCustomRect* self,ImVector_ImFontAtlasCustomRect rhs); +void ImVector_ImTextureID_swap(ImVector_ImTextureID* self,ImVector_ImTextureID rhs); +void ImVector_ImFontConfig_swap(ImVector_ImFontConfig* self,ImVector_ImFontConfig rhs); +void ImVector_ImFontPtr_swap(ImVector_ImFontPtr* self,ImVector_ImFontPtr rhs); +void ImVector_ImDrawCmd_swap(ImVector_ImDrawCmd* self,ImVector_ImDrawCmd rhs); +void ImVector_ImVec4_swap(ImVector_ImVec4* self,ImVector_ImVec4 rhs); +void ImVector_ImDrawIdx_swap(ImVector_ImDrawIdx* self,ImVector_ImDrawIdx rhs); +void ImVector_ImVec2_swap(ImVector_ImVec2* self,ImVector_ImVec2 rhs); +int ImVector_float__grow_capacity(const ImVector_float* self,int sz); +int ImVector_ImWchar__grow_capacity(const ImVector_ImWchar* self,int sz); +int ImVector_ImDrawVert__grow_capacity(const ImVector_ImDrawVert* self,int sz); +int ImVector_ImFontGlyph__grow_capacity(const ImVector_ImFontGlyph* self,int sz); +int ImVector_ImGuiTextRange__grow_capacity(const ImVector_ImGuiTextRange* self,int sz); +int ImVector_ImGuiStoragePair__grow_capacity(const ImVector_ImGuiStoragePair* self,int sz); +int ImVector_ImDrawChannel__grow_capacity(const ImVector_ImDrawChannel* self,int sz); +int ImVector_char__grow_capacity(const ImVector_char* self,int sz); +int ImVector_ImU32__grow_capacity(const ImVector_ImU32* self,int sz); +int ImVector_ImFontAtlasCustomRect__grow_capacity(const ImVector_ImFontAtlasCustomRect* self,int sz); +int ImVector_ImTextureID__grow_capacity(const ImVector_ImTextureID* self,int sz); +int ImVector_ImFontConfig__grow_capacity(const ImVector_ImFontConfig* self,int sz); +int ImVector_ImFontPtr__grow_capacity(const ImVector_ImFontPtr* self,int sz); +int ImVector_ImDrawCmd__grow_capacity(const ImVector_ImDrawCmd* self,int sz); +int ImVector_ImVec4__grow_capacity(const ImVector_ImVec4* self,int sz); +int ImVector_ImDrawIdx__grow_capacity(const ImVector_ImDrawIdx* self,int sz); +int ImVector_ImVec2__grow_capacity(const ImVector_ImVec2* self,int sz); +void ImVector_float_resize(ImVector_float* self,int new_size); +void ImVector_ImWchar_resize(ImVector_ImWchar* self,int new_size); +void ImVector_ImDrawVert_resize(ImVector_ImDrawVert* self,int new_size); +void ImVector_ImFontGlyph_resize(ImVector_ImFontGlyph* self,int new_size); +void ImVector_ImGuiTextRange_resize(ImVector_ImGuiTextRange* self,int new_size); +void ImVector_ImGuiStoragePair_resize(ImVector_ImGuiStoragePair* self,int new_size); +void ImVector_ImDrawChannel_resize(ImVector_ImDrawChannel* self,int new_size); +void ImVector_char_resize(ImVector_char* self,int new_size); +void ImVector_ImU32_resize(ImVector_ImU32* self,int new_size); +void ImVector_ImFontAtlasCustomRect_resize(ImVector_ImFontAtlasCustomRect* self,int new_size); +void ImVector_ImTextureID_resize(ImVector_ImTextureID* self,int new_size); +void ImVector_ImFontConfig_resize(ImVector_ImFontConfig* self,int new_size); +void ImVector_ImFontPtr_resize(ImVector_ImFontPtr* self,int new_size); +void ImVector_ImDrawCmd_resize(ImVector_ImDrawCmd* self,int new_size); +void ImVector_ImVec4_resize(ImVector_ImVec4* self,int new_size); +void ImVector_ImDrawIdx_resize(ImVector_ImDrawIdx* self,int new_size); +void ImVector_ImVec2_resize(ImVector_ImVec2* self,int new_size); +void ImVector_float_resizeT(ImVector_float* self,int new_size,const float v); +void ImVector_ImWchar_resizeT(ImVector_ImWchar* self,int new_size,const ImWchar v); +void ImVector_ImDrawVert_resizeT(ImVector_ImDrawVert* self,int new_size,const ImDrawVert v); +void ImVector_ImFontGlyph_resizeT(ImVector_ImFontGlyph* self,int new_size,const ImFontGlyph v); +void ImVector_ImGuiTextRange_resizeT(ImVector_ImGuiTextRange* self,int new_size,const ImGuiTextRange v); +void ImVector_ImGuiStoragePair_resizeT(ImVector_ImGuiStoragePair* self,int new_size,const ImGuiStoragePair v); +void ImVector_ImDrawChannel_resizeT(ImVector_ImDrawChannel* self,int new_size,const ImDrawChannel v); +void ImVector_char_resizeT(ImVector_char* self,int new_size,const char v); +void ImVector_ImU32_resizeT(ImVector_ImU32* self,int new_size,const ImU32 v); +void ImVector_ImFontAtlasCustomRect_resizeT(ImVector_ImFontAtlasCustomRect* self,int new_size,const ImFontAtlasCustomRect v); +void ImVector_ImTextureID_resizeT(ImVector_ImTextureID* self,int new_size,const ImTextureID v); +void ImVector_ImFontConfig_resizeT(ImVector_ImFontConfig* self,int new_size,const ImFontConfig v); +void ImVector_ImFontPtr_resizeT(ImVector_ImFontPtr* self,int new_size,ImFont* const v); +void ImVector_ImDrawCmd_resizeT(ImVector_ImDrawCmd* self,int new_size,const ImDrawCmd v); +void ImVector_ImVec4_resizeT(ImVector_ImVec4* self,int new_size,const ImVec4 v); +void ImVector_ImDrawIdx_resizeT(ImVector_ImDrawIdx* self,int new_size,const ImDrawIdx v); +void ImVector_ImVec2_resizeT(ImVector_ImVec2* self,int new_size,const ImVec2 v); +void ImVector_float_reserve(ImVector_float* self,int new_capacity); +void ImVector_ImWchar_reserve(ImVector_ImWchar* self,int new_capacity); +void ImVector_ImDrawVert_reserve(ImVector_ImDrawVert* self,int new_capacity); +void ImVector_ImFontGlyph_reserve(ImVector_ImFontGlyph* self,int new_capacity); +void ImVector_ImGuiTextRange_reserve(ImVector_ImGuiTextRange* self,int new_capacity); +void ImVector_ImGuiStoragePair_reserve(ImVector_ImGuiStoragePair* self,int new_capacity); +void ImVector_ImDrawChannel_reserve(ImVector_ImDrawChannel* self,int new_capacity); +void ImVector_char_reserve(ImVector_char* self,int new_capacity); +void ImVector_ImU32_reserve(ImVector_ImU32* self,int new_capacity); +void ImVector_ImFontAtlasCustomRect_reserve(ImVector_ImFontAtlasCustomRect* self,int new_capacity); +void ImVector_ImTextureID_reserve(ImVector_ImTextureID* self,int new_capacity); +void ImVector_ImFontConfig_reserve(ImVector_ImFontConfig* self,int new_capacity); +void ImVector_ImFontPtr_reserve(ImVector_ImFontPtr* self,int new_capacity); +void ImVector_ImDrawCmd_reserve(ImVector_ImDrawCmd* self,int new_capacity); +void ImVector_ImVec4_reserve(ImVector_ImVec4* self,int new_capacity); +void ImVector_ImDrawIdx_reserve(ImVector_ImDrawIdx* self,int new_capacity); +void ImVector_ImVec2_reserve(ImVector_ImVec2* self,int new_capacity); +void ImVector_float_push_back(ImVector_float* self,const float v); +void ImVector_ImWchar_push_back(ImVector_ImWchar* self,const ImWchar v); +void ImVector_ImDrawVert_push_back(ImVector_ImDrawVert* self,const ImDrawVert v); +void ImVector_ImFontGlyph_push_back(ImVector_ImFontGlyph* self,const ImFontGlyph v); +void ImVector_ImGuiTextRange_push_back(ImVector_ImGuiTextRange* self,const ImGuiTextRange v); +void ImVector_ImGuiStoragePair_push_back(ImVector_ImGuiStoragePair* self,const ImGuiStoragePair v); +void ImVector_ImDrawChannel_push_back(ImVector_ImDrawChannel* self,const ImDrawChannel v); +void ImVector_char_push_back(ImVector_char* self,const char v); +void ImVector_ImU32_push_back(ImVector_ImU32* self,const ImU32 v); +void ImVector_ImFontAtlasCustomRect_push_back(ImVector_ImFontAtlasCustomRect* self,const ImFontAtlasCustomRect v); +void ImVector_ImTextureID_push_back(ImVector_ImTextureID* self,const ImTextureID v); +void ImVector_ImFontConfig_push_back(ImVector_ImFontConfig* self,const ImFontConfig v); +void ImVector_ImFontPtr_push_back(ImVector_ImFontPtr* self,ImFont* const v); +void ImVector_ImDrawCmd_push_back(ImVector_ImDrawCmd* self,const ImDrawCmd v); +void ImVector_ImVec4_push_back(ImVector_ImVec4* self,const ImVec4 v); +void ImVector_ImDrawIdx_push_back(ImVector_ImDrawIdx* self,const ImDrawIdx v); +void ImVector_ImVec2_push_back(ImVector_ImVec2* self,const ImVec2 v); +void ImVector_float_pop_back(ImVector_float* self); +void ImVector_ImWchar_pop_back(ImVector_ImWchar* self); +void ImVector_ImDrawVert_pop_back(ImVector_ImDrawVert* self); +void ImVector_ImFontGlyph_pop_back(ImVector_ImFontGlyph* self); +void ImVector_ImGuiTextRange_pop_back(ImVector_ImGuiTextRange* self); +void ImVector_ImGuiStoragePair_pop_back(ImVector_ImGuiStoragePair* self); +void ImVector_ImDrawChannel_pop_back(ImVector_ImDrawChannel* self); +void ImVector_char_pop_back(ImVector_char* self); +void ImVector_ImU32_pop_back(ImVector_ImU32* self); +void ImVector_ImFontAtlasCustomRect_pop_back(ImVector_ImFontAtlasCustomRect* self); +void ImVector_ImTextureID_pop_back(ImVector_ImTextureID* self); +void ImVector_ImFontConfig_pop_back(ImVector_ImFontConfig* self); +void ImVector_ImFontPtr_pop_back(ImVector_ImFontPtr* self); +void ImVector_ImDrawCmd_pop_back(ImVector_ImDrawCmd* self); +void ImVector_ImVec4_pop_back(ImVector_ImVec4* self); +void ImVector_ImDrawIdx_pop_back(ImVector_ImDrawIdx* self); +void ImVector_ImVec2_pop_back(ImVector_ImVec2* self); +void ImVector_float_push_front(ImVector_float* self,const float v); +void ImVector_ImWchar_push_front(ImVector_ImWchar* self,const ImWchar v); +void ImVector_ImDrawVert_push_front(ImVector_ImDrawVert* self,const ImDrawVert v); +void ImVector_ImFontGlyph_push_front(ImVector_ImFontGlyph* self,const ImFontGlyph v); +void ImVector_ImGuiTextRange_push_front(ImVector_ImGuiTextRange* self,const ImGuiTextRange v); +void ImVector_ImGuiStoragePair_push_front(ImVector_ImGuiStoragePair* self,const ImGuiStoragePair v); +void ImVector_ImDrawChannel_push_front(ImVector_ImDrawChannel* self,const ImDrawChannel v); +void ImVector_char_push_front(ImVector_char* self,const char v); +void ImVector_ImU32_push_front(ImVector_ImU32* self,const ImU32 v); +void ImVector_ImFontAtlasCustomRect_push_front(ImVector_ImFontAtlasCustomRect* self,const ImFontAtlasCustomRect v); +void ImVector_ImTextureID_push_front(ImVector_ImTextureID* self,const ImTextureID v); +void ImVector_ImFontConfig_push_front(ImVector_ImFontConfig* self,const ImFontConfig v); +void ImVector_ImFontPtr_push_front(ImVector_ImFontPtr* self,ImFont* const v); +void ImVector_ImDrawCmd_push_front(ImVector_ImDrawCmd* self,const ImDrawCmd v); +void ImVector_ImVec4_push_front(ImVector_ImVec4* self,const ImVec4 v); +void ImVector_ImDrawIdx_push_front(ImVector_ImDrawIdx* self,const ImDrawIdx v); +void ImVector_ImVec2_push_front(ImVector_ImVec2* self,const ImVec2 v); +float* ImVector_float_erase(ImVector_float* self,float const * it); +ImWchar* ImVector_ImWchar_erase(ImVector_ImWchar* self,ImWchar const * it); +ImDrawVert* ImVector_ImDrawVert_erase(ImVector_ImDrawVert* self,ImDrawVert const * it); +ImFontGlyph* ImVector_ImFontGlyph_erase(ImVector_ImFontGlyph* self,ImFontGlyph const * it); +ImGuiTextRange* ImVector_ImGuiTextRange_erase(ImVector_ImGuiTextRange* self,ImGuiTextRange const * it); +ImGuiStoragePair* ImVector_ImGuiStoragePair_erase(ImVector_ImGuiStoragePair* self,ImGuiStoragePair const * it); +ImDrawChannel* ImVector_ImDrawChannel_erase(ImVector_ImDrawChannel* self,ImDrawChannel const * it); +char* ImVector_char_erase(ImVector_char* self,char const * it); +ImU32* ImVector_ImU32_erase(ImVector_ImU32* self,ImU32 const * it); +ImFontAtlasCustomRect* ImVector_ImFontAtlasCustomRect_erase(ImVector_ImFontAtlasCustomRect* self,ImFontAtlasCustomRect const * it); +ImTextureID* ImVector_ImTextureID_erase(ImVector_ImTextureID* self,ImTextureID const * it); +ImFontConfig* ImVector_ImFontConfig_erase(ImVector_ImFontConfig* self,ImFontConfig const * it); +ImFont** ImVector_ImFontPtr_erase(ImVector_ImFontPtr* self,ImFont* const * it); +ImDrawCmd* ImVector_ImDrawCmd_erase(ImVector_ImDrawCmd* self,ImDrawCmd const * it); +ImVec4* ImVector_ImVec4_erase(ImVector_ImVec4* self,ImVec4 const * it); +ImDrawIdx* ImVector_ImDrawIdx_erase(ImVector_ImDrawIdx* self,ImDrawIdx const * it); +ImVec2* ImVector_ImVec2_erase(ImVector_ImVec2* self,ImVec2 const * it); +float* ImVector_float_eraseTPtr(ImVector_float* self,float const * it,float const * it_last); +ImWchar* ImVector_ImWchar_eraseTPtr(ImVector_ImWchar* self,ImWchar const * it,ImWchar const * it_last); +ImDrawVert* ImVector_ImDrawVert_eraseTPtr(ImVector_ImDrawVert* self,ImDrawVert const * it,ImDrawVert const * it_last); +ImFontGlyph* ImVector_ImFontGlyph_eraseTPtr(ImVector_ImFontGlyph* self,ImFontGlyph const * it,ImFontGlyph const * it_last); +ImGuiTextRange* ImVector_ImGuiTextRange_eraseTPtr(ImVector_ImGuiTextRange* self,ImGuiTextRange const * it,ImGuiTextRange const * it_last); +ImGuiStoragePair* ImVector_ImGuiStoragePair_eraseTPtr(ImVector_ImGuiStoragePair* self,ImGuiStoragePair const * it,ImGuiStoragePair const * it_last); +ImDrawChannel* ImVector_ImDrawChannel_eraseTPtr(ImVector_ImDrawChannel* self,ImDrawChannel const * it,ImDrawChannel const * it_last); +char* ImVector_char_eraseTPtr(ImVector_char* self,char const * it,char const * it_last); +ImU32* ImVector_ImU32_eraseTPtr(ImVector_ImU32* self,ImU32 const * it,ImU32 const * it_last); +ImFontAtlasCustomRect* ImVector_ImFontAtlasCustomRect_eraseTPtr(ImVector_ImFontAtlasCustomRect* self,ImFontAtlasCustomRect const * it,ImFontAtlasCustomRect const * it_last); +ImTextureID* ImVector_ImTextureID_eraseTPtr(ImVector_ImTextureID* self,ImTextureID const * it,ImTextureID const * it_last); +ImFontConfig* ImVector_ImFontConfig_eraseTPtr(ImVector_ImFontConfig* self,ImFontConfig const * it,ImFontConfig const * it_last); +ImFont** ImVector_ImFontPtr_eraseTPtr(ImVector_ImFontPtr* self,ImFont* const * it,ImFont* const * it_last); +ImDrawCmd* ImVector_ImDrawCmd_eraseTPtr(ImVector_ImDrawCmd* self,ImDrawCmd const * it,ImDrawCmd const * it_last); +ImVec4* ImVector_ImVec4_eraseTPtr(ImVector_ImVec4* self,ImVec4 const * it,ImVec4 const * it_last); +ImDrawIdx* ImVector_ImDrawIdx_eraseTPtr(ImVector_ImDrawIdx* self,ImDrawIdx const * it,ImDrawIdx const * it_last); +ImVec2* ImVector_ImVec2_eraseTPtr(ImVector_ImVec2* self,ImVec2 const * it,ImVec2 const * it_last); +float* ImVector_float_erase_unsorted(ImVector_float* self,float const * it); +ImWchar* ImVector_ImWchar_erase_unsorted(ImVector_ImWchar* self,ImWchar const * it); +ImDrawVert* ImVector_ImDrawVert_erase_unsorted(ImVector_ImDrawVert* self,ImDrawVert const * it); +ImFontGlyph* ImVector_ImFontGlyph_erase_unsorted(ImVector_ImFontGlyph* self,ImFontGlyph const * it); +ImGuiTextRange* ImVector_ImGuiTextRange_erase_unsorted(ImVector_ImGuiTextRange* self,ImGuiTextRange const * it); +ImGuiStoragePair* ImVector_ImGuiStoragePair_erase_unsorted(ImVector_ImGuiStoragePair* self,ImGuiStoragePair const * it); +ImDrawChannel* ImVector_ImDrawChannel_erase_unsorted(ImVector_ImDrawChannel* self,ImDrawChannel const * it); +char* ImVector_char_erase_unsorted(ImVector_char* self,char const * it); +ImU32* ImVector_ImU32_erase_unsorted(ImVector_ImU32* self,ImU32 const * it); +ImFontAtlasCustomRect* ImVector_ImFontAtlasCustomRect_erase_unsorted(ImVector_ImFontAtlasCustomRect* self,ImFontAtlasCustomRect const * it); +ImTextureID* ImVector_ImTextureID_erase_unsorted(ImVector_ImTextureID* self,ImTextureID const * it); +ImFontConfig* ImVector_ImFontConfig_erase_unsorted(ImVector_ImFontConfig* self,ImFontConfig const * it); +ImFont** ImVector_ImFontPtr_erase_unsorted(ImVector_ImFontPtr* self,ImFont* const * it); +ImDrawCmd* ImVector_ImDrawCmd_erase_unsorted(ImVector_ImDrawCmd* self,ImDrawCmd const * it); +ImVec4* ImVector_ImVec4_erase_unsorted(ImVector_ImVec4* self,ImVec4 const * it); +ImDrawIdx* ImVector_ImDrawIdx_erase_unsorted(ImVector_ImDrawIdx* self,ImDrawIdx const * it); +ImVec2* ImVector_ImVec2_erase_unsorted(ImVector_ImVec2* self,ImVec2 const * it); +float* ImVector_float_insert(ImVector_float* self,float const * it,const float v); +ImWchar* ImVector_ImWchar_insert(ImVector_ImWchar* self,ImWchar const * it,const ImWchar v); +ImDrawVert* ImVector_ImDrawVert_insert(ImVector_ImDrawVert* self,ImDrawVert const * it,const ImDrawVert v); +ImFontGlyph* ImVector_ImFontGlyph_insert(ImVector_ImFontGlyph* self,ImFontGlyph const * it,const ImFontGlyph v); +ImGuiTextRange* ImVector_ImGuiTextRange_insert(ImVector_ImGuiTextRange* self,ImGuiTextRange const * it,const ImGuiTextRange v); +ImGuiStoragePair* ImVector_ImGuiStoragePair_insert(ImVector_ImGuiStoragePair* self,ImGuiStoragePair const * it,const ImGuiStoragePair v); +ImDrawChannel* ImVector_ImDrawChannel_insert(ImVector_ImDrawChannel* self,ImDrawChannel const * it,const ImDrawChannel v); +char* ImVector_char_insert(ImVector_char* self,char const * it,const char v); +ImU32* ImVector_ImU32_insert(ImVector_ImU32* self,ImU32 const * it,const ImU32 v); +ImFontAtlasCustomRect* ImVector_ImFontAtlasCustomRect_insert(ImVector_ImFontAtlasCustomRect* self,ImFontAtlasCustomRect const * it,const ImFontAtlasCustomRect v); +ImTextureID* ImVector_ImTextureID_insert(ImVector_ImTextureID* self,ImTextureID const * it,const ImTextureID v); +ImFontConfig* ImVector_ImFontConfig_insert(ImVector_ImFontConfig* self,ImFontConfig const * it,const ImFontConfig v); +ImFont** ImVector_ImFontPtr_insert(ImVector_ImFontPtr* self,ImFont* const * it,ImFont* const v); +ImDrawCmd* ImVector_ImDrawCmd_insert(ImVector_ImDrawCmd* self,ImDrawCmd const * it,const ImDrawCmd v); +ImVec4* ImVector_ImVec4_insert(ImVector_ImVec4* self,ImVec4 const * it,const ImVec4 v); +ImDrawIdx* ImVector_ImDrawIdx_insert(ImVector_ImDrawIdx* self,ImDrawIdx const * it,const ImDrawIdx v); +ImVec2* ImVector_ImVec2_insert(ImVector_ImVec2* self,ImVec2 const * it,const ImVec2 v); +_Bool ImVector_float_contains(const ImVector_float* self,const float v); +_Bool ImVector_ImWchar_contains(const ImVector_ImWchar* self,const ImWchar v); +_Bool ImVector_char_contains(const ImVector_char* self,const char v); +int ImVector_float_index_from_ptr(const ImVector_float* self,float const * it); +int ImVector_ImWchar_index_from_ptr(const ImVector_ImWchar* self,ImWchar const * it); +int ImVector_ImDrawVert_index_from_ptr(const ImVector_ImDrawVert* self,ImDrawVert const * it); +int ImVector_ImFontGlyph_index_from_ptr(const ImVector_ImFontGlyph* self,ImFontGlyph const * it); +int ImVector_ImGuiTextRange_index_from_ptr(const ImVector_ImGuiTextRange* self,ImGuiTextRange const * it); +int ImVector_ImGuiStoragePair_index_from_ptr(const ImVector_ImGuiStoragePair* self,ImGuiStoragePair const * it); +int ImVector_ImDrawChannel_index_from_ptr(const ImVector_ImDrawChannel* self,ImDrawChannel const * it); +int ImVector_char_index_from_ptr(const ImVector_char* self,char const * it); +int ImVector_ImU32_index_from_ptr(const ImVector_ImU32* self,ImU32 const * it); +int ImVector_ImFontAtlasCustomRect_index_from_ptr(const ImVector_ImFontAtlasCustomRect* self,ImFontAtlasCustomRect const * it); +int ImVector_ImTextureID_index_from_ptr(const ImVector_ImTextureID* self,ImTextureID const * it); +int ImVector_ImFontConfig_index_from_ptr(const ImVector_ImFontConfig* self,ImFontConfig const * it); +int ImVector_ImFontPtr_index_from_ptr(const ImVector_ImFontPtr* self,ImFont* const * it); +int ImVector_ImDrawCmd_index_from_ptr(const ImVector_ImDrawCmd* self,ImDrawCmd const * it); +int ImVector_ImVec4_index_from_ptr(const ImVector_ImVec4* self,ImVec4 const * it); +int ImVector_ImDrawIdx_index_from_ptr(const ImVector_ImDrawIdx* self,ImDrawIdx const * it); +int ImVector_ImVec2_index_from_ptr(const ImVector_ImVec2* self,ImVec2 const * it); +void igLogText(const char *fmt, ...); +void ImGuiTextBuffer_appendf(struct ImGuiTextBuffer *buffer, const char *fmt, ...); +float igGET_FLT_MAX(); +void igColorConvertRGBtoHSV(float r,float g,float b,float *out_h,float *out_s,float *out_v); +void igColorConvertHSVtoRGB(float h,float s,float v,float *out_r,float *out_g,float *out_b); +ImVector_ImWchar* ImVector_ImWchar_create(); +void ImVector_ImWchar_Init(ImVector_ImWchar* p); +void ImVector_ImWchar_UnInit(ImVector_ImWchar* p); +]] +--[[ END AUTOGENERATED SEGMENT ]] +local cdecl = cdecl or '' +cdecl = cdecl..[[ +// Helpers: UTF-8 <> wchar +int igImTextStrToUtf8(char* buf, int buf_size, const ImWchar* in_text, const ImWchar* in_text_end); // return output UTF-8 bytes count +int igImTextCharFromUtf8(unsigned int* out_char, const char* in_text, const char* in_text_end); // return input UTF-8 bytes count +int igImTextStrFromUtf8(ImWchar* buf, int buf_size, const char* in_text, const char* in_text_end, const char** in_remaining); // return input UTF-8 bytes count +int igImTextCountCharsFromUtf8(const char* in_text, const char* in_text_end); // return number of UTF-8 code-points (NOT bytes count) +int igImTextCountUtf8BytesFromStr(const ImWchar* in_text, const ImWchar* in_text_end); // return number of bytes to express string as UTF-8 code-points +]] + +return cdecl \ No newline at end of file diff --git a/mimgui/cimguidx9.dll b/mimgui/cimguidx9.dll new file mode 100644 index 0000000000000000000000000000000000000000..dd2416a298a8deb45c9509f49ab08e6f029f7f77 GIT binary patch literal 543744 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%0AFu1WHn#85xn404M8jsB-;d6d3jgw*U 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�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 z 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
  • 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 U+j?HN} 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

    Y_d@q@3*I+UwcbNOn%Gg`mZ60R(cu=_|gt<9T zaX&wCuR&+hXRd4Ie2)mGmitw$5Yfxnzi(Aj%Z+MkK`NMa5vG=_gf9J&E0S@^g~Tj{ zaFH_4obA8H>ioqTHol0vFlu!2x5eYk|Fz6O;*{v(fO9FA-v6L4R$6~ zA%aANKEq}KV@EP>D7g9s27UD}lW`dta(e)*NdtZ)V9)~b3Q{$N>sqPK`T6ICp5P-^ z^EFJY)Lqe>RBesh+V(5}OkHs)Ns3-8H!c`Fx-e*^nfj$}Q|FCZe?Z&i%t+T6oo=d1 zH^;PtCxt($JrZ`7tM_U?@Bp6CB)JzIA`llmCDl;MXlv)MncPy@nTvG(wO%J+rDENT z?9Ua?T6OHHp}7+_AvqOyi%f=%u@-#!YoWzDIYF!9em*ba3*=V2X@&GL%TA0wl#E>v zMCY+!m(Pk5+lrmfM#w(gE!g!P`W)|Ms1LH5=NK%@PS5AU4M&Y`E+dg}AI{i_8G6%k zxT5O2pFq;M+l*hcC^DB>+*rKm*&goQaaL3DI8btA#x{}s_6z)2plb!}TBa)hYIhj^ z(oH4JpmS=OIcqwUngxLSdj~^w(hMj#nxAgP$7zK^LsPga;}Ga2ivWIiyAv}mbir1g zRNVElws1qA+rD;Z+5*BN26w?ZT7z4h&tnCmZ8v7-CeZ-X?m{xqGZ0ri0mw4ri+iKW z%XED0HiQ1qdL}>@{adowY5ZI61R=aE8>A-`=yvC2oU^FpG54q(*)RNW zA=O^M8eRJ;BqJmOu7$x~pXW5cq_ee7)zCvCDI+|3xxvO+t*0wzwhn<-t7p(9<(`oRW<7*gBg)P4tPcLvQ!)imWKu?bO6{jSg_sN6>WTam zZkQ+){9}(=yJC$`daUMu2YC%%QENXzy*3L1o4sdfkcLmwd1tzT-^@EVxDQy_%=^r| zWY%377JiL5r7?U2JONW2`P8NxZtzRZKl*Lj{B~aIDG}XJNM<|te%!S_?8_aYgcqbI6R;}1QeyvskXoB2(S4Mc~8 zTXA5n1i+gQnrk*CuV+Q{dT)6486}i!bpf=1uGkXX>3Na`4i9pB|0s)=Qesjh$6n$X zb{SCy(a%_RAOK8Lv|M`MFM+)R*ZX>(k}Q6p=c*=i7=*0ws_;=0WD*mL$yL8}g&8j! zQoEMDexYaO1tPiM<4IIJln6aZRen#@8{ZnOS+>n9CWww(W;culr3qt)4?gK!fs2CC z&nLK~uS>li9Ld}MDn9BoDo4EKcd};l1t5|UO4$-+{YksxA=9ElQ_V$EO`(TMilpCu zDSKc;P)wdLhz(tuUTzXzXa^q};pHhjyJ5T}{V!uCAf2;er*xxKC*5Z?-^y^3I0d3_ zfsX5;CBckgWM<_e+jBxk(R2|Xb#Q^Ek#rC}k2-5j(Dd```B+OI?_F5I-C8M5&P)HA zSju=2y5G8dn|PI2_M`g7M1U1C;A`-aELylxrB$sC7X_#ETp95~3kLe8#$C|gpD9FI zAg3x&04(yF3BQSO?SP_9(syku!vqs7yfHKthO8h8VtRD1ZG zB6tievh5?^}P-pJV~gGEICt~7z; zXKv~!-Jj4AfVR8c-ifwrFDVeDCSCQAB8_J#5&=2u5MFdMCDm2uia0OK!CZyWs#8=t z{9iUb7pcpQ@?7V_@2eo78md`~5~r7qJb4HaQ#F_BXOfY`x z)YS>M8Rp`BQ4INj)WCrWO`(KEwJQ+Ds*$>w&y>4NGiXwQpi4hS=IK z*8TsKrftEvIcnBmp4!p7f~%d;z?0T*1ZgN%yv^mUa4jeins0CNtBo4Tru>l5DyOffRs%X?el?tkVYf3Yv7*j{O6e(Ov zk={$- zo5<|TWEO}dvq1VmnaL^n2WA!_QZfsyXUyDLE=-l6D^t?|3@qSFZUOgvKmib)$J8!m z7zniCv{QB74+I|w$bTjXY}I_Fq|=&UXt4d-ekAS$jY_(vJdaVE-A2LK1dUvzJz?k8 zyOgMv@KHoHU_g!N!>Vo`6m^rCr}lLyqXM~eTb6q1e^iPP`V^EvACC%-xvDLI_u5gm z8W?Q}8(F>2R?{$dsNhv@a=%g<&u%seTOPJW#S#RC;l#ozP9cCJ_D8-+XcRmHDVX@r4!QU2GEb$64HP!rH)}e+8 z!p74t91Jz#us(iQA4OUFk=*HQS`(zpyQOpK8TFS9fvxJ7^`p48iepv{Yf)89OhieP zWL2+FR}aw?eNwCFL;~Lr4Ps14K6-au z8YDVe;ZH@^$a?d4_n`0S2*4Bvn6D6+PG@l%Px)z23ndx1N&P!pRto~mkfCK#th8MH zFkBXm*qJ6SsjkwgKyg%Q{z+0Qrd6>VAx~9CxvqFfw&Em}C@3?(D9pK$cVB15!9(fy z16kp`ylh@b9L^t28<0ND2)r8boKRvq9bDOrXm-um^S$8>jy{9Gizq4b?Wf&rFqgouY_FK z<#E2efnkB~LvUB=i*>g<@1dV$R#G$Tm9fLcY)F`G@5MzY$0I%u9*!qF!k!Bjfbj*f z;^$zsNP9ip^`^Rrh`IYM=uEu;Ds4_Ov*KScbe9QIb1MTuJgNwd_0**&Q+qXLGc;o2 z=Aya6lZs$=1 zjh^a#5y1igzE&*X0@Ov=*4dzF;YKLcOx`5b$hJ!24YI9L8xuK?aAG;0gg!XAkgeIo z!?1jx$oSHD=g*i+%-hVOx30&J#f9Dki;Ta481^kZHpiT}XcX4Q+%_jM-e5-m54(T&r`%iisONM+0iGPd9Frg#2OWnEdp` z{xAqP*W!(8S(O82{SvhM%U*sYswgf2Iz_^F1GNYFx!d6V3u9%1^0A?+dKv@1^hkR`U%E z4j`FMOK13Ehw)Jnb#!`>UtUP;Onm}p{vqZ8XO-uq+LB*LAB}ZBzu*K>xOKmmWXZ$l zC7r843r#Fk`#C^|6iA7GJzeLVu0l2W1V}N55#@XPrqbJiKhHsg}|AulY_G?<~ zB29*tUEodryKpT<2n7l zmbRYkfis&mRr-d?NSd+Ls7%Ew>LZ@r>JEIkOw?sLl1e(SpvU_u)`=w-4CSsN*?b zryB8tV_b8-^bvcw8}K~7_1^Q#b~TPl22X}(QDmyZuW4l*hsH|a!-dCMG!TCDZhC9n zL89Nqw=NMocdHwI!97XKzuFDIAaR6|N~(4%f34n&oPhQ$MAlLQRIxJIyh2>q~( z(mvc!4+A-KDtmjFlk7g_=n`h(BonK1;$g)TZaqU?ax6WzC1^q1OKRm@n&^=^PA8E~ z?XqNWY#7w$Rlf zW*uc^A+POZYDQVKVDb0Wez+pY?)2)*k6O_1@;HvUM5u#{*JxK zYrisO(NrvWH vZy>!In}!H=JF|vrYCMLw{GOJXnMUlH&N(|qp1&bI`ui$@~bc~ zG8dDy@SJZw|Mm)>_54fC`|lgm)&yHA*;3ZsNX%XTPnv+5 zsK7WsHSb??LEBO=D<7BW$EBH%BptLp^Azj5%!+TwMW#5df+goCXEdFu@cTw5XDmHq z!I$;gVDUG56M^)!G*#yu;uWJwpBe9AhOSU}UXO(vaIzd$a)y_|Vc;6CO82P*Pc zNQByRuimym+H~dCOe=W0bX(Sw;_Qo5Z9OB|tPO8j&rG&9?7EYE0EKNH@CIhO8qX!) zv+_h%F`fVbDVB_DOMyH|u|!kIQ-6x2_k8P_E^_w2QaHbgNmpx}s5QP%)z*e>cOvC{ zB)MEFIa`It?i-t2E_Ix_K58m?rQUjGTOA-OS-PmbzQ29XOtd!wxgZzpmUNZ<#f6-w zelU~X^Uer)I~D;g3)51*^^E6ELjL66S=O;YdZ$#d>>{V6`7 z`c-|_D{WC1@`AKzAY6;5Y8B({-`Jh8O&)yo!1sp&wzO1RbD7DN8m-;X{o#O>>>M)y zuxx^=^4gd@U3~3lr4x@bPGmWLy!-eoW!>|~a7ysbg`?d@bINH}`=rUc>PNkt^-7!k zOC`1bCj0FhD3+p+MLtosYth9VMEuHvapXp(te5kgIqdnQUC~#U@F#9CoxsPESH|oD zn^~`P!Wj#&&;D~pcMQq(mk-VLZ|85JFW2wzH+ERA|0Vv;gRf+Se{NJ>kn>cC zwqkvx+_PdxdK=M<-nUomZ8}jB8QFB=QX(Imm_T@i{k?fBX5`EuP2bdWB1c7w{JoA- zzulOh^p>Y4#UH%{=bLdlFK=voAX$z9zp0fJ1_a9BnZLK@FYJi<-x40Tdx(j?AJC`#G!}ejKheDDZ@lh!nN3c)0 zzUbKvg-B)szx~PnuKWR6MPb*EbDVp!KCR}H!Y|8beGG-5LwQ3FU8wJY-+f>0z8|FT zCqzHV`%vGV*5xC@90Xvx=Jy6LNmNOg+of) zdGmP{e$wA7VkZVgFXsC-A|5mjQ^DlU#L(WU&#E{e#mM7ju@i%%*mtCyp{4Ee>Oy7o zT97;ruLQKK3}{5QsRDLR*-&Gj>g=~qeG2>3P-CCMB$adZOxHezNovs5 zGhO>sK1m6qNOW#Mkr&B%)gK1|+W68($PIm2aH8 zJZTm0(Bt~;oG7Ok$~XECD#BoUXgMD^DjkOsBwyKeh8RxJOP|wKqAEk}CI*uE{B-u` z@ArQmWIk`m{=B09^I-G&ne5MZr9YQSD4Afsh6C)c`$qkoZ$3@ze?KXmEqiiJ@(2HF@WvGd<&2Af%(tx4U#_&`+CE(PEi6ip0RA;lAtEpo}$XDMwQbSKlJx>p;XK>S2oL({&UAg-#6+Qj`aQFW4RhM<+ z|Jim12N=BHM~6+Dx)Se5P>^vabEHFdHc}28g#AD_W_Ll{bbDuV4q7rAo(*>P<{w2GU{IKl)ejeXHzC74D=Y74e z-`DGUU9ao)lZLjQ(om**8A6xt`=rvHgOz4l+XCI0x)n{mB-q`VPs(O}kGgkK_s&!5 z_PgJlFffRFLC8xmb*WjB7#zm7Gh2jeAJSra{(B8&8_jJyrMXPEW)efW$D4jf2LLtb zO^oBi6+c_*Jr-e}H~rjmnf+HU(~cV-;)4}tKqn7Ym!98z_PH2ZSEjr7iZkjO4kbOy z-yMK(Q_A1eIUEwX$lpCY|M)-Z=Z%r_6!_Q((03F{?c;~`)T@0MwGZ^yt9uORk|FIv zCvj%=9^F5siQ(?jqBEMnGRY1YjSFFsnEp$mQNtL!4_%A1S8f#Aj53b#Iw2duUKVg? zOgUqohJg)fhR@NPsL^YNN1EYtY{x%n20}47dt4TuLz@}lUhuIYqe+Ec+3->@)1G-w zroEBBk>_UGpW<%|f4=NYdl7#v{EcUmgHL47<|RWpsa4381RDlVwg*DX(m~X?6aZC^ zM$H6X;2@jieU&H9rC0u!(1QPZdH+E9H@g-W&fh>JKK~W1r3BIy%fm zbTb?{C9BJE4CWU95N6Z!&%fR8{`tkX`w!)gBSc)+k6>fLN>rWlGMUCOdW`U_?TeS= z;2Jq@HI^Zr2FwJaWTMAIO~TkqO}@dPOnxsYHQej1!2D%_rTZYbNW=5io#0RWkGVzP zr9GJH>S=2AnZ79|BZQSEAlHRa9L^Ol7znHl8&DjOz}U0TT@Ha-gJ`?M35{!LmICAF zIbk{iO2@!V60+%!_^=f&e%UdvQx$aTpx3Eh_Z9GAQ+5ByPWJ~7)2)!#t+Tkyc;Hvc z0T+H^x%*VQJ|KhGwMiBy%f0L^CN)GIgHGaxoPZv@*#fVgM~ePf?is)e#01=1;J%## zZ07uy0sVvW3anZ_?|)TZfmO?Q!R`8&+ZSNf(qDlBJ`Gqs`r}`KSMl&J;CdgiNZh<% zGP8x9DR8~=2eM8Au16e%)sGPUkVPd{+@xuZ@>n;yJ2Sd(xU zWIxnS_ec&mdR~4X;h}M#CI%O;BgZE1;noeZpYP=(yir3?$2|ugyTv;Ys6fN|sj(Kn z5tNy5)Mx}mA)9!-Z>9NGM?LD8n?(P(h?`j?qFW3GH7AUN`sp&i_~qbE2Bv5@9)lgb z84iOpwc%l5AjBT-zCK>N*&i!@LU;fU3OyGWvzqqR!Po`DDQ=3ST|F-?HYVPj9&bq} z2-y*wykuhB-kv6I2g=>o=F7tQag-#kve(h*qaSBJ&2HI)0nm1R>2d^6Ojkk zzsnY5hiq|M)9{hr0W3C!b~KhfiC|%L-45gM-*e917=FT}8vp%X$V}>_BRPn67#Tj- zcZf&&XrN$6myp{xQFVoT8CY02B=*^DadAkW#j@1ZK8f3#C354feL~dv zcbp`Zr1_e(gI}NEm#NiQwH55pk$CQx$K*HDG_@h(#szZ?QhLk$09zq$V!u_l|Tp8CGl3ByU z=UtzWh4z#8ABIfhod#zu5sD|-<1D5w)o6%yFRjy5jHxYyyH1ZUG_wu(c;udT% zU8qMdkD$aHTI%jN1)F#m(V*=Q(lK?S=)qm3iGz#@yja1z`Hv~UHHDrOcADC2uYZ~C z24hVY;bGnHUN_gNGSP!fQ7!BN&eMS+H+w~>Ku9a`STV~>GKUiQz=NF_5@^e_&xSpUqLK;)m;!5 z)PEnI zoZP(+(x)SQWYqQ{O3Pm9&{g*_62#H}sJH2Qub}OBiHYzJI`Fe+r2xMCjy@!Fn(fYe zT?D-;$FJU*K4kue(q98EU}FpEv$_j{XQEn~c0#b1bYEzsN@$|WS$@eR$)2`UMBXZ~ z(#NmxN%t3p#))q)z~=Vhj)e{hD4Y_XcYb*SX3Jot<_E+(kMmeFd(S=ib;_)=(^h4> zN594zX`HQj@s>}!FRoB+s6`M=HD8xLICHR6K0>>a6x5{SEjEtyO2#MRU1XR-aEt!q zEies-aR5x4`6a929dIIJSTc?a4)uH|Tc4}Hp38T|PCDRAs0Pkrmny4!3Rc!@|Jeez5%6d0AB?~fk5xo~@#!9j#YL6L(4rhamqv1ddZOa4QlN$QJkm+2Pg>8_! zCcQ2@ne_{*kWSo~GojtNZUJ)N4pbwu8_h9LIX}x8mH}lDT)aKP@vO=i!Lox!tFOA5 zTv zne4yXh`q2ln-`DeAXq=>WxP|?)pqwp1o05^J`z6Qgb#1$(RX}CAl-Q$F>xpJG{hbK z2M2NC6mUFD-0(rLlSfm~;64T%?%~HC>3By(gx_XyJ@qm&5Q&&v;)8imak1Tf9lo{s{jAq!;dl0ccWAdpk*mWpio1olzr7ZK%sgfDhUQGS0z^QzqZ1J0ZU z$s2P^o#K&462&83Dl01NTX~eittBJUj1o_4s2}A}`~D-kK2`Tiq!B0O9eu1UKNBCx z!WCa4bkMvQy4riYClikqeq#m;PCY}{`uc&jZfC8t8flkN^4tE_N~A@qq+i*Bimdn^ z>^NTH_eZZw&PX$0w72`R!CJ4+8GxXw>$5!w8mRI5Y`Tc%&NE`Sw_i4I_PBZO#cGkt zq1#`BipuoHk`bW%wzvSQ{Ih~_vCk9t`|&NL(X*LZZSkkP*E}j$o+UH>1A`h_Z>Y5Y zZ1=k};)9+;eV)3M`;CzC5U`QvowX8u720BiGWZ)LNke46IfGj$P7YQ$tNZ95ImW(O zWRkL+_Eci5yWpqtIyN`{#4Xb0SV??mgc^OZkC(f9pe~bZ#iFFMHm`AxRa_{3nF@WckuxQ@u13^3zwN*kh5?C=rbd8U+)^E{t!N zp7~n5m))=V_^|V7t!E^Q2DIVTb-Iux|uA zDMUL2C0;jx68()#&~;1|Lcv3DEl=Gs0?(nqp`x75Te3UDr^b#Gpy$0d58Zd#xqgmF z-rRMNXB=>cl+YdQ&7td3ed+uU)00ERjk%rU8eiUfY6pgnEu{s=`0d>q;Y;ZyGyX$$ z;^iJqVa9N{xwB3j*`HdK?os+HdTZh#I0tTdd4*tW3?<*N{@847J%J$5|BGJXxVE$$ zwOibPwUrQIEiM}2H+A5rjbLIEB&;%se$iNQC1!1XcEa-{v^%>or_=(?6IzYD7fxHH zxSutT6D5vNJDFBLgNdlG zYc3^nR_mhb-J371NY2`6J>6G#;`}?#NzUE*q@d7W{Q(zE@J6GTPW{ness2e#eJvv6D>|7D|)MzC&IEke$v!1LHx=?$gmx%l*8A+=H4(fb!iYluXd+51$ZYBynu`3tTfz&PF{I#Q%BRTy0;3xG!n_*jHZt1lWYH`N+XG~ z!1OC(9}@8kCw9cW8@4?h3J|H&-f-Z~%=lZMT9tupidq)qXfzbdfWJQdGyE)#WyRb3 zR}*-k|4UYJN9spemb2?L?5^{}1~;N}E^1kxm|Md%@nWc%17Lkx@Fs8k9zW~7;&+Qx zIYTy)xYE$s49*0TbPR5{wSBpPeJ zQ}1xE*_FCNxHIqqEp%y@+!^*L^{V`f-HOblS`7bn{pNf}JZUSZuiT@zC5Q-UU z)II+zLZ*npqi^YS_`mKZxe|7|UtSLq59gqgdMnVME|aFpnk&x9Q~##4tio|}o- zgqZ-d=Dg8pNWn5Dknl2;)7JR*;(J$$Z|&cx!KjJ-#{Ci=y~dcREb@yPfRyaugJ1^v zmm6s4B;3}vkLm?dm|1B6rvQl<*GYs4d7ZQFUybng)njiHH9&c)Qb7e*d?;~Pa9n@r z@CYOa#O%U!Na**qCJ02ec$t9NCQ-Y33B6##JmHt$4SbX0Awpcst)vL(*CThuM+RXN z`^Ps^E0WTY#Co}YJ6ravQjd<9L99o=(Nh;1M8=a&g-wO zYEOeBRQ~_#TnWw`q0YyU{Daa8iF5ML^Xmw;{;#}Oex#Dhf{koS-+tR~IdY3z^7j^m zvsuAxd>Ryl1<~02(uLEy5R`aBqkr+9=n&?3D)=8K4X*D|z!2tmC?|obqjFkATOK`z z+(EWkqHI&5`jJHKX2U067abCQ;n`;lmEm10Q1=_1^xx=AH$3Fp%@y-+gqJ8R$Nb-N z+=cUm&vRnROY!H^uxLvM7Ol{U)z90$JYT%_Ay~lYg4*2ggDwwMKkW8D1`{myp!*px z8HvHtX6B(FcO~_p?1L*@XO$8wuSCxdbsBm z(Y3aaTrJi4x3b+<>MD$bmvJFXNHQ4qW&hT^i^%0(-YLS}?50lXju2cz_pKKMiWl4> zA*!+FUHyDfp1C0ys~im^lj=P-BmRU2bZYtAFz;w`&qGUIp!H!mGZm4ghm90ZU5+r$ zK1UlBhKm;>H#!{8!07J4EqW;85Njc_>~dkUj@hp{9~1V3&X%$xrO8xFk8C@orLI$3 zTK|4pBINES_u&q&C8zd5VMEscQ4T-kE!zwGq7&Y;`O9fu>;|@1xc{+EU{p8hW~NPN zQ|4f!Jjlek9c#IF{Rjz5_YMDK?F2|f!;byNEKNDv$}NAvTRG7Tazg7od%&tG=I|5; z$cxmSYG2z>!kPV(I*ML&()UE@NK)N@2~DD|4BXW% zvIVlKWvqK&@7w*Ip6w<8ZHG6imO(O4<#PiOA)6r?lzaq5O?i^FK#Gp;f(enUj(H;P z^-pLgG}I{~Mk>>2rzTczvQjIoysyes{M}r>>4Y`ukM!#sMl5JQ>d{|6zEg7r)jbsN z%j#6hn8K@jJSk)F8(F5-cJln#Hosp;)XJmh?Id_#4$1W|S@j24L#LX_khYL7N>NCr zad`rs5+YiWf$V4V&Jalvcljj>zwWb#1dzN)Xbi4lB^3}l0h(K@gxH@?yDC`{FD6wf ze>2v?zz84JiKaXWoF+FksqiKLmca_7UtTB)zkTu7R?-1&A5$r^r3q? z$%=zc?eoqLvwP1R>$HnyD0&w`#i-v*1#{4>bAX^z91)IeTO*8engni-B-b3{0e3{9 zjRk>uR&i%VqPo$2p6$q1Hi$(Aa}`AGI+)_<6CKk;UiW(F71HBjp!LNlWp-^2tD<+ z2OfAjIVY`YnB4SFOn5DM!?==i_nAMu)sHmP?q5F9{oHRT#B~j)f_u0syDW|mRsjCR zUwI2Gkh~$s{W{sX5w*^oEJOn3%KMjRyT2YzNT`{9R^17?6VNc2iB{&3f($}(J?mEP z6;h|C`@i@|WHhz3&739`Pfcr!-zX8We4p~Q#Vhp}Jl}W~zy1W-(KfS4Ubf9FHeb`t z*DL{=wwbWz(BqgnTV&f#s8hKd)53ojo=k{9MV)Vka(#KaFf(VRIkCg!J8xR}cx?2v z@Vn8hY3oIVEvwdv-|iy?x+2bN(FJw2@A#r~aL{xv7@n`gPx9q%?UM8BunsS`ZLN^fP zDE}f|+#Kmb>>LRy53txk6X5VRedQ@#V#B{llI_eaDx6sy6&p2A*6)P(HHJ>KhW-v5 zyyasTe1?3V0zUlgj88$>vZ_VinsUGTy)L6!!v5u1vWPaveZV(<5i$%&H5&Wx!E91N|M@=npLM9Hkw@7alx*{R>t61X!epXglYPn2Z2 z&(;aD@&m0JYY)!9u8Y;M01$Kl1s6y% z>hJg-FIK8X$E~aF^fle{Q}QC2q>pU!rm}v3;Jl`_qWM9T>xMesiWE~&f(Ken@x^r0 zs!w>YR?GJRs~+#-$aiN)FJN!0Uo^1vpG&mM>fIA8U?^teM0@(U`R+>((4+?0PRyL1 zm|2vVS=>7F2DWVq!yJ848;RC0&0?dn{r67B@8@V=hW!3HzbSoGOi#R7v+94~_3D54 zX0q0b{vbkN>xx}sPw~Z|q{%(ROSo%g-CeVNr}X(_r}o)wj@U3qdwBW?&L1*@Vg@nT z_15^OnWnVv4>~jb9`<2)WRVfJ>Kvxk?U1P?o{-o5*l_cL;Rs4W3Q@Q7UHvhdJ!sYK zgttp7CrZDbDE)Xx%Jm7}xXbXei>5X--}$*^AXyuShpZ+i9^2#=wpG=%``@8(Y{9g$ zeX+UDJvLC|tPKe5kUay7z~GV%*0waXjZlq`PAq)p_SZnDMnuRm0oEfx`Qb zu~n>wzsc{iV^+f-`O&1q&p+O@O(4Ghz;;2qjj?Z8q28voGTZgXqt~Zqcoeu}_!9uM zuRA?|FJhRFPdU=K_?@P9GR;h7x|*%>v8H>p?B3YKY4^xd#m2RUUQg@(FjKV8%NX13 ztzzs+=4I=av~K(!zfOBr{nserDNO_0Z3^3M9DrU;=eXZamGOphf!4Gxl`5y& zJ|^dFC34<2CG*HL)?GS~$JXJJbF)mNQgCk!wvp{#lgcS=ypFI>%a2c`vPosSyz;MW z`Papva+>QO$aA%lT-n?GimgVq!XM?VIXV*MSl}(q_k^G^A--?}<2)m&c-HFg6tk2QUQYi=WN#|L-#E2gr=~#_4H_vp;?|x{Yk!9M*r&Ep0pb^2T z=3uFmwqVJ)pZ}|2A8kD3c`mG0cYx-CQttlj3Dfdxf{9ZtXLv2YdKoSMhBpjvxchy@ z1u`Wc%5Qd_ou+%0F!n^}mRXjrZjl0_UrGV)-|t;OCQ}N;r9jLS80m%v3Y@P?eD3P! z0%UZaEq8B{jI&L~QEu))#^svvR_|=MQC2j1F=v#XOP5k;^>ZV}V5jnnG{LSw4-Q(?YLX4U_c8JJHEhjeqTdB6(*&vh+MVdW}|eTq}|j zKh#D=`r~b@{zJTU%eW{yy&_FNhezkR9TX#$kZ(!Ce^)8> z#GZ7j8yza$yCjiyC$Y=d3o3Qy7blnFZ_>~3i0_tzwS8uy#P77@5`rHAr=#$hSbAbi z!LU{7iDBjQ-KzUkWp;c2$L70}X&+@t!0`MEt|}i(mgGd-8#ZY3ttFN(?V4^}5Ue?m z^Lz>24a{1S&m=bVKsVS2pIIwk(Xl0b9;vrrC47c3!z>@Ma? z^hKvZw||Tbztc_idqWC9b&RC9EcA^L_y54mGGqt(tU`9|`ZrGIZBv??7M~c| z)wuYC6FThF2`Rws*J^l{-IkC4t7a-d_|_@Zsm%Gb(7xC;&hm-QbKDrLi{H1t^+;#t zxLJu+#W6RYb4t=dK7Xpp_gBU5H0erj|8j?diM$5OKQ?^Y*Yluc*LLKP#m*u6x zCixw$8J|wc>-!7ztuZoll)Uda0SjnU~Wj)Z; z3%K!kOj39F-717p!7(!hIU-_XkHah>< z@^&KhNcUxfO;oDJ07aA+t6BrpKgf<1ww*F=3GXakxQX^cVU1=H+Mwnu$i_&ncB9-> z^FRYlA|p5`^T$5SlkoG;C1N&baZ~CPW|&F;l`tg8+H~uiP2m&uf3X_=A|<$dyvjEW zKYBl_>Ad8kwEVrY@O5vEWEGpvg?^psv@`X8ZJODC!}O8S%;}?}X)^|NAr^WBp?FhJ zMT5}h?jjEV%UCmS4Tn272Qpsfek=rnv42VRESWn7u1@tqXZM6w&fPqpm4qY{O0h4s zkP&yzK_xM@p`>~VWx4YYOe@2K)-&_wC9=oOFGqO04jG=1!GJ;kHf82CN&q|edHbFI zqdT}5(yI|*k_<6rItbp_nFF-uA4tTILk30AX`FAjg+x^l*I&)@m8g9xQQJ}fm*_d5 zocQzoJcCm(bV^pFb6?7FZYVCe0S+0GJP`cs8;Y(=`sWbX#R>J~ALkIw=z!1Yw5!vi z=IAV^`YESx!;*Oa$k?SN@wXA;6o$9lKKy#;Wqb#HC|(P}GrBO`e0$*fM683PG1j&j zVj1N0L2Sg@5)_BvsYRgL2~#%CZfi+|AF)DhQq-y4g0grA<`_>U!X54lsKt8hd$9sS z>>;{66-S((%IpADUpBP-qH??NH_NA6+tTB^(w+8r-^duc88!Q?@qg_8aQwt*&|7=q znA(v}37gFJHxBqYR42Y&g}=Fd53N&S&F=w=Tc2VJtIy)pU16ci)Gii@3x5!+5PvkckrdNb+D{?Ig^K3wAfFb-qmNV@h`uRu67pw>h?X%AEQX!lEg2ZD8ty& zKb!vDjNMtv3H!o!euuZifaaZ|23GuhDe;KrTiBigdCBJrjbozS*6k1ynul-mDV!S{ zenByn+&qmE)}+HI?Pd025N3_vCn3wkjXUlfYg)SH;Tdbvv$tPpWLiVw=>=y_>mKfL z!Rg0Lpxqizps1?*%`)1v7Ko$o5vHnL-Ig^TyM-zbP1S&=)aQG6gLGCtiWZmy3cPzl zz+vVz5{V#Mf4k5T^NXEbLa#pK#5%3nEmnBHj4wI01b9yRF_!31ul}kFr((HGp9uJ< z0yKP?`#^^|ze0~Fg?NrZT`J>~R<&n3tzkaFGqzds=PJ20_J6_I2*iuvccOYH`;}-E&l}cq$#gk zCHhg>As;Lp$^N)*$o>$c1l=F)41fmqb>mow_*kIynnSt|8E_5811+~tHazC|w7gZL zQRQV2b#=gvZnGk(CgoWe=vUoO8Rj^K$pH89cd5}mwly9l^8`%TKbAwv=#Pm4L^V@W z^Ih*S!|8W5lM@VY;$!hcy!n;UC6pLmc*9;%Y)yK7#kJNX#kDIwCa%V>98|O7bea#k z6_ts0$Dr7i!&UiDmx0D>*)lAeSqr{X%cP6?j;_;?#k_kSgfF{N;KYd?UK=D7M-%3dwBQU`=O=vEA1`cL-Mnc@D= z$anfVl43A{WH;9V6;xE3!#peLL|*-_+xaur$QLb?wVc$xJm0vA32pi<|1+0j2k(CO zDJ`3s!@l@!^(OSh!kf?lCVR_r|CHwL^v$AS5&{_z@rRGgCE^q9Xkhv9##Gn&HnvBH z)lw`7@{w4cL8W6geq80N-r%LdF`m)WL5E-Aej>Lbl2saTVRSCMnRY zh|#>#FcQ7(Q`RH}l@&Khssa*9uwlay7fWyt^!$7cIs~RzN*K$+Xw9immYVoMS z=7#{t*WXlHE&RyfFd4X9R5<)&AENsnLaqW(gKK@4%ghDuISEfq=>vfctNt;1Oa(&! zRO+gl(~X>FwO!J^dL+R5pv{~962+_7e^TCy`f97xMCY`!3}~s8-UYSil4&1}0W*dS z;r1l&Wa{|#VjBcCpp1L1U$i=sT2Pc~Kj%|Hw%hhNvUJr)2-ib+fwCum|Nex-_q9Ku>FlCajZWmW;d+|baXNR9tY zV$!o3edkW?QB&yePBoXe=y~FsHxJJ_C|J4=VV=z!q*>P1@LR`s=hZ;9EQ0JCVsa$< zBw>U)lSOMB^Y*^H<^LvRLO=rZ65`96azMEJBY6ZWqUk?NlbiTQ**hQib@_a^kNS9j zAHcTe1Ejp!V!@BM>bEj-%mt$#iT6#uJu}`{u;Rja-xbju+|WhO#iM9+OuP?|Zt=cJ zR>SYeD@~>QqE`-Nr{ERQ4@-6mPLP6^Nx?}{aIq8&VT-Pfq)Rrh5wd+!np?7hY%{F8 z>&X%CE4kxK$6NeSOJ0tQ_kHn>%($DE7)C_lXpqrHKPj@3s*n2+L`BQ!2?u0!!4k|7 zIV_O!K}3poZ!xqxH}tZ6{82vsDj&y}B+A}}K9n+v@IgGlGS$#>WAL+c*xJ^T7=|~? z*zhUMs=2&5%`;(9JA>2*^ACRny%uCM=$_i*3QByv4(I@lIxJVw0UsdbXSY&hsQysy zfc{XTYxG<*(p+oZLrf=^iu%|1HckNanqP=Xmo>?o9O%mb^YKgJ8{l z+&B`UlZA2nBA;(n3HmQt+|itDo|rSPI=KD3sQ)&gbvSjNK9Uhtw&Y$Wk#2 z&ytj{kU}<1%*lAJ)epb8bX?)?m6;i>iPCXtcjP2WCnieAx0dFm85f7UvV5{%JpJ=r zgNDvjKmReq*X`>(=T66mg>JBb(}zD2gIu|S_{WjS*Z+Bc|CPj7y;l!EwG~jOB`Kxy z4sci5F+pIsC*c4IiaxzPU@ZVv#6ZBSOVC)j*LASg7yj!JtiyMzaSe($(F-LhrSmPX z#w}7kD5F$g`9mS}y1abV02~N8K z6=;1Qm@nR>ul7|$FUOXq@a5=-)Ty-Ci=6IQ`VXqxRK1(r;&2%~Cw0UN`!zj*ms>o) z4OFdLX2|?c_LSem&9rLc4zU2Z2XvIOkv#E#hPtQd^-wF8KoR$^U(<=dU(~Nq=3s6Y z%WO-)mz3c~^+}D>YTw$+3-P;tkUvi&KX{t)hR~OjWKmM48{)j?e!=UaIVQDwe&{76 zZ>ojLy;yO`Ld)NJIh$mic^F)0X%f;;NWx%Qr_?W$g?A`G;6&UI{9@(0%Q4k{Le6W| zw^~DWC_hK$C%4^#n0IMf7N&A;1v;bT##c!Q+yrLhg`L3MxL;p-KT#jK$QUcAtCG?RrF+9W>N_!&|>I)=pe6rq=G` zUwO~9oASW_Pu4EME*)6AtiFM@6A>~efmu0lmbZ9cd+B{G-giF#e`E2!ahtbzsUw8_ z7w?${3dP$-4qpMc3Bf2h6apwy4>-jg^QWM?*IUt8-S55#k7wSYY5|Z?UozYdY>43U zjg<&N!tL%|TaAV5YDO!Dcd^dG*x}mGc#27$vvzT|-Z$uM{n((h^>WxEI9cy=^B0Nz zsjCW1$8fyv{s9Wp=sOQf>@_HR+xsIaxww3GuE0tjsdw& z1@U)uzXsec_@QXW!fEVvR2Q@VrvX}YJ0U|UUxO=(Ge`(skEtv~4tjdJ9&aJ8IQx1W z)AhLiSEsCp;1pSpPu(T!vCr+sn+XTTid1}=+QWslUA2{`dd){gyTZvSd|PBN_`Y|h zZg(H6lKJn^`R^-tKaJ>FaZq#wnPvJD(+c0lk>kzxu>j{SJlS7Ly(_m$lXq&9v3uY5 z0vvHKg$Ka`Tq6puXD+~>P>k2v<`_I}0R%gru>iw$(*@j`pQIMx*eMH8k@21jp!07V zxGAqV{bF)Dc_aXLfuJ0#1lqE3Vy=)IA*g}rfsqQweGT27weI4M~bT0(ZJ4dhM z&a3o?y+(pCXt*8Y&=xm8!AL0B>z3=Qi&QjO`(%TJS~LzO(9KSISX%s~nsA`4KxP7I1o$Vtyy3 z4zuApB21g?+qN}zXwAq!_s+lRtg+`K0ws|5OmR&%97GX*MoK< zf)^9#zC(`MYBb;(1!Rkve)qrXbl~EEShxWzuA;h>{&=We4oub77Hp^r)O225c?=wv z6F#dLS9*ctF!EJ}nrR6)BhnoyCq6)`yh83o&?vhdI%(+od-Q!RagM$)@@W|4zQT8{ z*>Adk>092h8LwkoUH?Dpbbg)$KF`-HOf-aUMu&}=}i`V>GJ)koW0mK14_K)vMBVJNPbN5sR)Yzf2 zh=qwL_v3O$or`eK48ZnWFG*ynGX`Ll&G<|aI}dxItavB3>B4NdCRK^^WpTbiIjxGz zht$z@Y902MX8~!HZsresAj@XYU^q%^e*)L`6cTIOAen-dem-WA5{zV3@ACTw1_VBr zyD|OrHw_b2WMh+)C6rDc`v^41=@^u8prnFcZ{sj7_SL(&LFq+>@~QjbMDKoh>fI!o z;s?+@@4|OD<otiq`zs%E|TA9jY4ad7ld?&7#!=VP(1?@M3 zYK;B0$T5QYLQgZ!75M601}_?z8gAAg`GXO6N>X4loA=#8k2-<=@WT2?e+_GYVder( zFP_KqC-*5=0oElZS5SK*FQo>ALlRZY{-)$4!yy?b-<@Rq zrm5OqGhN@+h=Ty);)S;>A_$*k2MP$($&k45adxRme)yobK8&iv3nM2>Rd&+d^&uU9 z7#z~fJT`U0>t1nVa&0Go0u|@pU7<_2W|s6!F0Y*Us)r!K(kcZov6H7Y@yDf7^iZ!F zcK5hTKMmV7&HbObf@AXPYHeS%mW;~AR#vmUezsJqQIa$J5SCFx_#_`j>PBQXU9yE^ zbCqqLl9Ip$p;7fFTnQ^hX_jkICL&Sfc%0qtJ8)(}x*V5urpNtnE(Pq^A(Zow{pr~& zo_7C?fr{+)JphN^=Gzso;RHxF*1RFEYRp0D@m^LCflYLXeIn(9!K{dn^^sePEB=4z zQ$njSr}O~25q}*ie351F#Tll24lU!}rkO8MP`Zn6@$5F=FyUg8XmRZp5}Ci!teXXs zu6;@$he{ar5>g`+qWeS`3jE+~UEPvAUD_HYi5-n_=Ln`Kk~!_e9)jR;~axrkY&m>ec%ZRu2$H*h@%42rge_Rc+* zY`EfSE6I|1OO)iEGK_yP2&W`Bq1|m;tH_4ZZEIz{Q<#s#z)nvj3s!yU*-430^7x;P_}7a8vIl=H(pim zECZe42lcP+sb~BKs)pW3)H*a#`;bs*Rznb~(7Uz>uQDqU?jgQx5`2$!ih<01qE7Au)%ARoHKr<0 zs&s}VVY+o36)NqKh)I;|z#O&mR?gdI*dn|{=5y#zI&&J!4ydClJWX7&yD{{J%+X!v zNVmpYSG*!mR?~f~9Vw&5-!?-gd|o~_t>6+q!hJ-cn+Lo}+`JU@Ql)i8vo6NP)}+wM zJA{&#?8G4v@g>RvOb2CE>Kw*J=9?>@l1@k#?G)c-^ypVwhn5~E@9ER-fu!(wC)UG+ z*lUb84<_Igjja03Da5-Sccto|^bvOwbOPqo9Q;mMj??yLCyHgw>4e={7l6LwC=N|@ zp6ANJr1!sh$a(#Pd*3|t2~jWWB>+XnYuG8*)xP0N#P(SAV+6;jwniDFu@gs_CUhdK zyZ>(HYqj74hTmb`{fbF}FrReDTJvl3wD=(5uB|m~l1qYgODtlEUcRVZ(R_=9*gVh; zx+5C19zNCkF`tG6Fs}MU-Y)?(`;t=wPU{12*5=%3Rsq~1Plu{qFM;ERmBG=2-26hv zIPb(W%1zB|SPd&8scwV>-e|(SrCTJZ>SJowp4)wCyg$vvrEtk%M9<=(zi(-~WLu}% zh;;$r+ZwS{u4y>8RQENDWNt#^Ww|%?BC z`hFFAWjOM9#2ZlOVtnfcsO>@#Vw0gW?51E(NCuraVx7X$uI})fdC<%;lLll-ySU%v zVIeR@i4RC8X>#E%t0ME3QboL>lifklaT%`N(c5VC$^7Pq{(0C5ct<_v0_Y60%{~C1 zCVy{APz|0&B@Yep`&yD&;g67Gp8IzgBJ>*H${d;N@7Lpyn?A!1iN~$7eKI=`ze3$9 z>QIVFxbDWkbm(A;|HYh)7iulEu}JcwIwb>WjPWMvBmvtx8;A$A=v0;%jl^gHzC8R{Y^8QayCi#wxzd708T_O-T zgBsM?6lw#vkDz}_a6UCy%b?cCS?Vcy6}s!zJ!xLQ?6P|e5(+&iDU3uQqTwOY4vFDE zE)NPnByS!`h7aSSaT&M)btO^;cqE&Z?B8MnB5T*%LR~Dixp*|YTR=5N;WM<(yA)q3 z<-N;%Xp50mu))>K5?6Nl)n%Lzxm)2!a;}|rw#&K7dD4Uh6FH)6Pk!bR9QT!8gsoGz3L)MZ~KCT zTa_BenHp1U_<rIVk>z_yoXZfv1kr(<7`3FUXItC+YRDYe$ zY9VpsciL&u^YLKlB!tHFh{{)s(e%u_?qvU|-Vb$s;yqPE{P(DEmPtlzUv3C$uJd{Y zS6)5}l%g$SHN>c#RrEAQP+OCSeE^gvdJ^#1BL`ke_oA5{ky1f{O#IFr!uISO!uEV5 z;y%5?5J_7&`6*hxM{z9bC%Wl_a&%ROHY+PNSPc$JdFvW%MhT0y-y4Y#J_91|TL|lb zP0{O-`5|i={1(_goM6UZok5zN-E7lpkdr}Zsyrq5O2rCuo$fMpkCCL^crK-q*=8QLD z&j}ciE?aQHI8SKeNy1Sx8t=~VdM1v&oX}JKn^nhm)KwDnEC&btAERPn)*hzr%%z+~ zx*IDqrwXN{0j7y5y#QYf%kq$KV^PnnC1ZzEB*Iq&2s~CDb~q-3{ej=td|D9za?8$)nM(#2Msx*iV_06uCvx0D&v(D-N{9T*(iji@`+fw)FtyoN zrzoRPQX9T~1QR;M6Z!CEDVILi5)a{FoqUN;LL@?Sx7UrRL+|`K)m3L9x~v#1wCo)B zHm}q%r5_h%M%c5d(sbN&C~4+^+LVH=VJ{&k_K=C(vc5>|q^%d+q$}8Nt@$c_m3&N> zad9q)E^8dE%lM%$j2lXw6_0paHcVc*?n~b}+fXQ?L#chrFukNP4|xtu!?H~Gn`bRd zFSKwGh3lR+ihmb95djm`zqEZeUwEWb@?}rN?RiC30vu>VVjAXs0S^OoN=iK?HI4xS zNWmHFdj21Ahrw25Q{ZXdW5^GP29(~grTT1{8*vvZ{D!4W7(6+tmAS>=VQS(e<)oz0 zrAnd=#!%ZJ$DreQ02eQTk`1Xk|9i{bO~lC@EV7Jx4Fx2b&XWBLUiN_wna;3)UiMQu z12lV`fv%GF00kLK3dFquXpcMu%H z;V%hcuNbV&(FhBd%3Pwv?CZDUzvV#p>cBMw{I0FiOH<}A`#;%-)pV;j3EHR zxmbwsvYJ`27YEQe;ubdkoo?lNi}!d+g|G^XcTq{@ zo&i4h!u>pUSd(5PYuQO_&7T;f6XWVeWd=RLS`}T}@dpfP&+G|bv>+Lq_lH&K?1TJZda__Ut#;ckXC_s9JXZFwqt1t_;i1tms6hSWVgFr-d z(ww4fK*vr_txWn?!5f_MG+L}yH{ zNGBy(Bq_1KmE`kY}LC{{_8uO^%8b89ZB&)bS3*DHzt0D6+DwG;GB2z)^y6nNyOD{Wy4YNg{jJ=CspjFr8l! zIzhHLl}MM45E4=lb;W_?^qGb<+w2*SY?gTy6`1jVg^~2%b}}21?1DsDR^ju@=Xv}C zVa&uSkEPNh&lAtyI6>B{4t7`tBe3i;)8Jace zSGw0~_S`YTy5d>o%=syWA#`BEGZUVz*?(e@u(xD;2i2-@R-mmY%S)I=!0>EDVYsqUiYpjNna&O(o>ccwh{fkZ(?+Oyst2N zNxW}-^rCp*N2BM*`|gSoxV2WatZ$B@WnCRb4|`?oTCwK(-xnVt-ApWFn-a;WnV!vR zcht#w3OM;T<6*6812Y^6%5EjUP50;TFk|u!jHmQ$?KSaQ1}wmD4@faJ<6VE}A^s#|bro-x0{>h+8M;O6PocI~sP}Q@g+f-yB9Oip2YCFJ){TWUXy9PX1`3HVP*WSi2iKY0tqU`}@OK_`_R>j+Hvu3t) z*P3E3tkvMps$V2asG|zLlOfK!1WWW%+W5)_cLu}9x@TJB_ef?hCwMl+=;3{tWMA8( zM^A9El)zI-Y2eZ{*ub-tE!_1kD3DCW+oq0!1gvbH$L%f&5c=2hRJ?5*Wene?_;F6O zs^Z6`8_%>GOuS<0DF^$~he!WMiRwMnZ+-uHFj^5oXCh2rm zwL(&A40HGg%l}8@Q4GSS3M@1xVY@|bR{TXSN2LC{kZu}`z3OEiM;FQCB$~88Zp?lb z{*GB>swVEX{!i!~k5f(L8)3-4B*!xgEP7B?NI@3$R8pun z;{GR5hP4@8w<@7!4R0EX7;LX}i9#wZ>1>BxhAfO%Wl_tOM~b5<#7L{cw5s%k#9A=i z@II?P1gMJdBCEcTU)H2*h_5U86-SsI6U`}=LaaZ+=24NaGL+Yg41y}3k!7ZCZY1uy zZ?WBDS%<0*yPrg}i;~rcr=U$8n6_RVTt#n?x*+a;b;rN+Yccm#Zm^YmtVx}B0P^F={+;T)YHFnW-QrX0*8`&6l&R3Ogh_Le_pztH+X6X)po{N;Y>m0rvXA{2eQTff& zaH@45(j%GsP!|Kx8`l_9UROn~Q39z|!jDqMm0=+pJw9;LLX8!r+^X<)0c&0P=57(x zgbzwV02{s!bqf#2V-YtG6jZQ(YM|gAa%_hSF1by=DYK?t0bDv~^tZMXAMiOb!}9bq zQ@WR_BaHJ)3T$w8(!!U|QqtB{jlq&39+hQ$4yu?kAM`$y3lW3(U}qu z0@fr2tt&bPQq)qRti#jDWP|Ad zu1bF;ofeMr_x87>)6F8|^+VgkovrNA6taHZuo~^}h*FhqRior0w^lpMwYN{0L%QqD z3%R6e(#;11jXS$Q zGjq`3U8V{^AFj+acic30DX*kBW!a_bK|wWJhrg0Qjzz7OFFvnqlB+$2P_-I{q=j{YvJ<_C#QR( zv+8zC!ZWZhc16Js3Fj62HzzIu!3x(-rVFv0*0_c%>)$4iVluE(wITzCDJBVvaGDJ8 zNXzV#Tb9U17M5Dpo2}HF9u;rHS+t1fqs(bxH(Jg+!%Y)i<00I%f#A>h%R=9kIz0%7 zj_Z%@!DT{!>?z#7yC<(kcM8XhW@ztD7e3GUI5x7FM|vA}yxaCiaRJ>PaleUq3;+{q zHV__Q{RN&)G?r%W?yOue8BeKnJ$j{77m!&?#vcaqn9EL>)N*ACZRTN9#Qp5Gk|&pf zBN03ORwIY_(aeXtcj23*LM{5E*~ddRk!_DF0Og_7|H87fdpqCf#kW#sw$NN)x;oLM zGO7T>BCgy|77h{W2tDuNv-gUxbERN2xnpZ2;!WvR{i{^MG<;Rii7Im&(w zu_07^&9~t9vMz(;Jn{zA(cT#MJFg&I)}bXzbG?RB_r-v--)R96VQvd*x(!c`;3;R< z>b-*4NvTW2{Y)y4FP#+MupxPTg3x?9dPyT=qHzy|&LDq=5mjdyUJ3qEKb~_{z&<6& z<#7UA-k#;$ zN{d(Lv9*g=`@2W!Q!Y>b)%^UA91WaZbt7P~u%lZbf~1NAROvguI}p2sHaKM`5TZJz z&azgbWm3K!ol^;M$z7r9KZJBPfmE+2yz1Yz2hY{jT4Y?bk0r`#jEXjwmMt;leP!p- z3-o?Ils{D#Fk86cz!xk}1goLhoQS95$aVcKXS2fMaf$D`xBDaH&2Uyp*XI!V?Hy^G zF3rg%KI{ZE8VJk@Sk4hR4` zE01+gK%M;~Fw7=&w7iw+?3(amOIKz_d&?`C@$S6&$r*Y06Z_j2gdEK3A9HiTs+`#H zwi4J*_@!QD%WwS8$nWeLd5~MMZ&7M2LMF<1;1re#mYN~N&2@ZCY{p96@1#vgADUIN zOa6He3>$Lvm#9TlGV-jaeaMh=j@ghvWmfD)a zcH-6fjo?hKnQypJgU8Yyv6~BD9zx&bCOYc0r^iETnuTwg+p>?1$KLao0HNb}b zdzS8OJH5hfrb50>>CU(I(VZWAENiA=JTqdhN=!-rWbraEnajq&Y*?lPrbV5}_b!tf zav^Onga4q+ZGO{~d`oM?yvb_$os^vXFO(eal`Q?!KPgGy+0QxVOet3N9MFe?Lbkx9 zuKkA&{F9#J#>LcPqnKAb4)r|Srz(0f3IcvbEc;6)n(!~#sg=nwiHEqr zTfo#m?fv8*$jvcHZ&E?d1V4C`4MRY>Hl*{k5O7~&kEc5C;ghrE*UoGHAHA>q+Ih`? z*ZavYo!8vB)ELrv)1TEn50W}WWhj(o&MUBFf{-`jMDAX84xZpny-}-wfkfGcMC_5e zRiZ=mlISrg6)M36Z*=Ek_2~4ujq?ZZ(8*A}xkhg|RE-vO?M+IsJ7V`_g4KLah*pj@ zVcS;M>p@;wwoWeDli>SRh8y`vc?D2UW3d4_nm0yFPMk&D@xw89oigR3No{n&L`MrY(8K+)hX~cxAKU02n|Kl@UzrcVnoTySq1D zmsw!Xf*mp(?ftnx2$KmA>Y48LP&JPqh&nrR&Q;52o|I3@*3@=IPDer#j*$)ls77DQ$9X6#|n$ybxGDJk8 zQ(kh*ixhanIf*MlMi9+_QVnrz4N@k&1ivRr=?yB0=Jwy&%es7|sR?-;GX0aHSOyxlu8^>p9-C9Q#BW018qCK zc&F@;FU&Q-j=2sbrHOlY3YAFxDSp9O*CX~}ysPvn6w|I(t!J#|)?n=-06jzvPy0Jt zS5JkC`Nv^@CStvg)mpj`Y2vDyMC@2TJh+SNrMox~3OL0h1BIn|wb_n;WMQf8gnDC_ zx0Nbg-i^9%Z(%R)h~N#{{*jO*78kjZHhasmnemc%=vba(6>%HDUq)fe%0~;Ii~c8W znF?Q9wFsu+D5vFt3A^_9Wwdl>s;I88)p^01+mR?cQn-KBbUbx;Wk%fJ>|(hpgw2^i zDIAL-$0BO@JiKoIyqB&I~EKXH}wTs|fZ$8d?nZN_peekV%p zwo<)CICm_72UII^*HyPsxhEekm=eu0{iU<7cbC)Jjn>npmCoxE?g+HJo0-vj=hVX2 zYA0LvNQV%x_KkMSA2T!V2*~9jm=3Fgp>rDzjiyS)vEdVdlRvP zIH(o7t2Suwxt&+iA zDtSYP1^CuT0)UuUBaN~-=<9{+K04gS&)OO(4co%OSmiJDxU3hZZ(~^xur5;kO8^0Z z*Dl-!mbuJXMlX$`MU#bYNo@wxs^Fwy%$Xb_u>)C7iND3oJ`Qm7XcWVFsD&#W(PgK^ z&M3Xj9B@13c;O`47ja*Vc)ca4NvDtgHHxX3HGV$;QnoKD=31VCXQd*epgUE`ESV@^ZD1Zc4T}t7V4B(~`*Ua1!1FtAy2K z@qRxs0=gV4-kisz7-c4ADa6uP>$oFfO(9K{P6W~gphX&A^9zypijcNLwX3X2Sd=ig z)|$^Up~p)jMOOVM`Q>1duvJz7C;WU;Y5d)^RTnJn-I!@F3zSFt$8I3(J++q!BhR^8&PH)}MJ)p4@+UkBn<0ZnN@^;v_(X*q=-Sb3=X zDus@G436+l2?K{pp9QsEh=csnK=KoL*YTn_aFVeL!?rlkN2yn7gCGc{(`D>9S7lKO zhOb%xU!Uk}7uQKD=MULu2eVPyILE2&bNoSkb3^4?#k~S6wS7fWaWF?um@a;+KQcxD zjEShZ9pv$(aumNRKuFyT6#%V4=Q%ic8U;LX63eYiQ@bH;p-mtL0Z!4WerL0P2$BOf1&=e6Fd2lW{ zM1LVzI;*>o7c~=AL|;`S`wNZ7Ju5Ed2QXVTmm+4?W=RDDo3Mkz71T1AWLL<%))X1B zq4YrxrfPt!2GL!xhKdF=S5dzD54?KSx>jSP zCcVPL3}$TMt`&&j#aLDZzI3(wQk-6|04s{zzs5^LfzA6hysdP$Ost;o=uV8}Mlg4& zyZE-ZJb`$MG2(p-J;!}K9B_Pz84H?1cH@l7p-f7p&t@ri9o;<7RwtoY#|w;S40aS> zSE&V?VZPI8gJ0}ThD5M88tMQ~(jvVLmbqlnAIFjhUxF8DkDW*|J1C{&H zxD}-gb<= z2p3ze4@)MKyhol6yDwTo$Y)W)P$Ap%UlKZG`~1_%kUj42#tIoCMwf;R>2QBZiZr%P zfFsn~ra!pFUZZu(n+?2a)6ZY-n@zGkXCg>~w{H583Gu!A< zRZ2v-+l3vs7cXJXZgkPqlr69lD-opXbm~*lP@VKy9t5W9WN6c>v3zuG@eNuQfT#&MUlb|R zHO>^+?8jGq41e7zdUcxc+MDw@dX9Bp1d6)AxjrzV#i{NCU1W6L=`VbFWxCS|zdhrS zAxFf$k}X3pQZQ-K0~l2e(J?rj;`Vhi))sD!WVvplcZpE=l=WBJT+vN43?jKqWRV=- zph!00JQv~VV*Uhy3;qaJ_p-gzJcI-QvATu3FnbErz==wK1RWU(pVTDk42q%DHvz6; zUK^onAI7GTn(X0}XjwL5*)X{cW{q=%17yT)6!h#z_=VujE$!BloI{#H+Nf$-mbGle znMLWflo)$T3F?*VvD@%oFQF@<)$&~bipu^Kx40i$ce1~&q>`0`z!Oea{9dMk4Pvbs z4ecSl)uxS2ZDdGaflO`BjLqaygV)o?<`q3dU-mYP5R({Wa586Ad9Vyfh& zr% z8A`9h<&3x!O0?Rq3jdA^xOiJ(d4{&LdOlT?h9~FQqGayEa5t6`*4g@ODy#0SYb-M)(Byay6ax?ork0icFM~! zNrGd`#-1keW3Pmc&vE|*3P~}~#CzI&L7>gqmAfL`gxcvt$Ds<~LL2)O4+ju1I)XAF_g607`x>t-@#%pvaes5C2>Mnba{ zoMHD5qnoQ_l|miywl2wYA_49RmgcAidZ>fQK2F<&l7JD4LsoztMXPQ}qNK_Sm9eJ5 z(p=oNI0+#YiV~q71fnhOSQ8pP?8D|=!>S*Mr=?261w&ROcdfhTirx6YhMLFmZJkKjL?Uc?HWlIb{j zrssM^0uzq-yWnckgyyd@pY^Hte+JTD0K)DFWjjxUyxScJhs-|)Cqs}y*CIO?pxvm9k>0iGK&MG2_a z(`A6)zhdbg9xCoVVS$&FO%X~)D)N4x%cK9K0TwM&Gn)h?F zhc*nyQW_D(+Th}S?rxE*8JD9{eQz3?P@*uSc_t<^$Azc_C>dI*$Aq!66tRkQ{38)Syo&&0R4n9PTLf%`M@a%5aOyQE*V|L__( z*4o;Fraq1>F5%75Z}I{E23T6T!#h59;)!cJI+?I3Y5&_aUbkJl8T%@LmKNQ>BsQi3 zBv0DEBA4gTL)IjnpA}=^@RTfQEvf83DqMPTn6l<(e#p$r1mZB||6%XVKKFK5@D`d}1Ci^y%L<wc^rJYg_6D zxIjWI0qX)v6$CX}s!t59h*Ut)`F+oQo|#Ng+rIDn*ZY3nNuKAq`*QBR=bn4-Ip^*| zfu)=1YBgtAk68_Dqeu2C5#rffDVX*kwjXbU$vLUvK0mO0VIOyf+JMgeyr2Mpx(xv= z2b*5F#Z&e(DmM<>&9_4G+JlRL#%5Lz%eAoG_Diyfolw=y0Haush?Np)mTrb{4^--d zWl48oJQKH|t?os4&>aWM(u5wuJvr$I~bz)qe;Li|v5ooFflLKIi(XoW#V!y|*6C|Bpj6or(axOqo zC1p@fZC|g9I)#FiPvB*EkxEOrNBc77_E9GL2qBd%G|V+Rxml)p&Fq`7mz|G|fl&-= zx$WH6x3Gj^^0SO$!il)PeKDnRg|qS$tJV)?1zpcz0Q@E^l2oFw$Vf&~HB1@FT1M3C zPH-EpaX9v~S>u^gqZ3eV{Vw-7t{h>c5*i!rNOL@twGeBQUArCI*reLlwvp6C!)Lc$ zyTi88mn_RR%JBi;f(TaYtLYFx_nqIe`h z1kR;*=WY&pb*~()kPi954B`oX9*P})Jwo;L9miE_7Qp>9O0u`Cg499$4Yx+ZLC+;^ zz|biN)#Pu#mqF3f#wK8UhSnTzR=nBo|q~zQ*FcS0=g*9a)w^J-_~3RxGIZ&(Td8lu_^TD_7OqnZGOVCI2;V zw|Wyt(t>)gzdG|3ZkfyY%oo7i)t{_q3k7Z$)}ffB`^XQ8%VjUPTo{a)uqYN}p#Gsz zY8kuq(RCB$cv2(=gO#>Q#(yGgnApvLx_z341R-GSC3ph;TVG~htjI~oBAg-JbJCwo z;-bi-KEPdD9|YY*+t2CTzuS{!+n3 zxV{PAg6}LK4_*PbkD(aEnvPCFBm_Hqsiv8k>4B#GkG01HnbxP^s67L=fHMMH0QD6P zj>ibClV}(d90OgzrEKRp+Mgl__u-ZvR9u+(AYa0GD}9xvoDaIdNm4jN0s-v4TJ1T0 zMFaGXtqb&$(HI8jTF7)~o$>u2c z1gL3OYyaaXtSp#IZlqj=+$zC<13}3bxo57YY1&y-CvK%L#yhF&V62QFEvU|UovJB_t}N#FXpEdjD5^uWw!DwS7(LQ3n32a&!#XRUe6CWAc9+o zKrct%6ALrox7`BwAEv*?!K(@=au#s()Edwv$1VcVxUqsTu(|Lfid*&{3o7V|K|zNB z*#BJ0{{+Wpv8S~Fj@3NVPJJB}b5ZSVFv{s_Gn9{5fYG8%jE6gmVU8^!cmHodi*cv3 z?Ka$1NY^a^7cgoY{Pay&)p3ISAtiEk`d7Z0zV)n`&*EE@&0ZLx8z-=<$F$~>S`7Qt zF;3|rOx>7CEH~rIIx$F95-r%oYjwr=o7PUykeIv9&fK83&CYm)=>A=u4CEeADr8f! zs#^v&I8FtYOSoh3*}z!qJku9pYYAK&oKGYhd@KPB3p$^~*h50+kmqk{t%C2*gh}hy z5;j-J@<5(fvCUFx5cW`rL9<>EU?j2aDz;c4Z6u^FTz0Q8r|AIat4BAB^^?QPS6nniGsV39IuV)5jH&>9Q$W?ElUbBz6~hU@>o^RdN``b$ zO>EO}@eJ8OEDlm=OMz{6Kp`+Z?wLzP^4bS^U3WUFI4>Nu8|fZ{ZIhr+4TZ+lmT;s4 z45nz0Solb67P9vcsX$Wb0~qmUpC>(LA478po5M4ok1&A^=N|ECyR8braNUnN?eh^5 z+wcI3>2{LlkUld7f;J@#`YRLK9hKZujX;o>9F{q`-VRnYwA}?>PF9d>&VB75 z5p}fem~{qJW`xKQEan@am$47K0|cWLx-HGpO=pM5nK<8iu!W2;lu3Q1Tq+*S7ZzaPk zIu3Y;-DAoIT=@<=#;>dvgP(f5%y8yzox{fVS4e#<1{#0VdsI5Q0l=lbr2i^3s^W8E z%9k;<0G`A$479(?#Wl=LV%ll<9M|q3{$Eep%mSy55(NO;6gA6^(NjEPOvQ-@wFpK! zhA(-Y!44#fLX4TvOL~DkPq3T3j|*BD?`KOU|BG5*I+iitjF?;bt(z)#%tR>x&oOQr z?ITVlXg$WAX*fVK;)wXc3>da(zZlp49era4%3BvJ6avT93GA8CD1dg?r%(uTeNj-p zhyvkUiG+(D!2|BBm$5t=*M0%ZCEnqeh>T61*=;EQ|C$J`@3119B}r6XboVQB*ZnId1{eTL*oN5R$YQp?&!HrGT$*|HW*PTey)I+{>3-|h#|q37G1WhS&XZA+cO zzMCGIIy0kb;HtL&`Il5@e`ljIiOZKwqIB8~yy<>6q|rn~e)yrejzXmMC( zey;VESiph)B&rL@)!`B|cMbY3`pS*A`d0dcQ8>__S4{-UCZ=tcs2o>(cjC;ocr|-N zOx>jv3w+R!SdlGQFc)@G1!PWw%l=nAaZB^G)CkM#2Yg;2`vrQ4CwBgC=6AZ|+w!BW zwSJb{2V)JA@6S(0{ z-VQo_lTcI;tNV6A5jqpyth4EGHEG)?uGAR4%D2yVr)T>w>CNK44xx1J=|N#1E13X6 zwoAenFn&RT`x!*G9!6a?mn}VI6O;nU`tiOmw zV4QKk(d{}%rqe;vqhpYIBO-*Cd6=)oV#g?b({nn5dEqiwFx8OOc28_>Fj*rKC9U#6 zU^0ZJi?dzy=&}q#T2Thkda9p-wjh;$8Mb|EqwPZw0sHmxQrEo^Ize`|BuWMu(Z# zj2vJBTaeHCwIHAMYbKwiv|H}0DC2hC2#KOHuKiXL(aOqUWt`qjB3ft$QNpk3D8}L@ zdG%{Ls$sHAZjx7Lb*LwkyrP=^@iHUWm@;ahQNTu!ymFhw@4)if$viSf(sOppb`T4Y zyy8XaAYY>g{~n8rDq+h7ib~NFcSEoUSrklBeIa@E996N5yAeX*s6Tb`5o!1s&IKGy z>}s>S*cGb_EBe)9SD`3BIuan}61!T5B=o#&o}N2B#>B36GqJ0uNbKt4cwS^?2PCh& zumD^}H?Ht)Kh9QRkfkCO`xs?dWj_v3ro#Bhw01X)Hr~T@S09$A#MaebOrYVMC9Gktpu+PoOBP1DLrs_@_q4mng_C`oV;FzE`2D&2fvG- z?RK#(U4otarPJxY=tGYBXu7nHPs^6>>#?75wWs@f`=dPd(ZDXZuOdE2D|HE zbe_Jko?Ss~Y|=fOZvcFapj<{*0L@Ad-0KhfcCQJvSee&r6;fH@v}8KnkD3N0G)nK( zT`@`rPDo&yVh#f*#4sPS)n2ew`vUZ~KI{YCnJ2+CaR#k0x`n8L%`1?q*A(kA>wMAF z0GViZ4SDU6!%K5Wy7hB7N%ye)jn>P}Slv_m?U}T{32T$|-UINr9>`k6f=x>A`5_GU z14*z$5$U)%#da5^H0~?f`zj7>LU8_iS1vrq#l39dWGF`dIcJvQ6k7Z)DmOzEm)CxD>0lZ#>F|n8&}G>$97Q&S@0feCom6q9kTft z9rv=n;b2Wt=e9z^_#@6aEm%NH#P&W3w9#tbH2Z6g-sx>i7u%0&&XGZ4Kc{)q;%Qq} zm*8=yr_Jq-4T`U2+GzZ&6aJNu)dXRs=RmlS6bl`0$-wI7B7Ks81p5bM;o{X5{brMm@ifu_M=A4;q@!*i^e8~#UWF+ zMbbS#qfFAJ2M$^f$ux)8omn%U;V{}*tnKJt&}%3I;U12(kVIWQzg`7CppEe8BS5D% z-IYpvrWhr*X?+v4GRwLIou4@YN=?szmgoVz39HejAU0QM$J^I71X^MlX(|P_gUQD> zu2om*o;J0Gp*8i~Vpe=N_8~!ZSz$ zSzq`K!ec}3Mc)LSY~3n%`6w+;9DskTAVP|v@@Ykxo(d%9CS6g+#gVAXdYo$Vw-Zpo zuTW0K5cmNtEEFG!Ec4M=Wb0cHaQQac)!t^$B%Rj1q|+K|#$TF?6HYH63n%EaUJNzX z2ruT9C#U1ZED?f51vxv-DCRJwTs5FM1yjB?(x@l6f~*0+~@rJLJ$*XQ9nvH@G!qXxv< z_#t+0MH^rBz?#)&kWGB!_aOv^=JEMAsvXHa_HU zv|a*!ejfQq4?IBKjV6r0i@n~J%6tz^XR?W$pDm8iWI+?egfLmq#Bq@31_+_sG9|Y1 z3$`+`O((N00YmYSKwBKtFzVz^*>omb08VGJHQ!viKo?~Cdi<0|i4}@B?hK8__?OtP zw-@+&z2)^<4#SILJt(vmXnsdoTz#>9j6>DT6V#1?BMA?FfY!rid%;B2_%`D+x%_nSLYP-cfpj7i$>9}}47od4S(0o^tdXATn_-H6TFL#Kl|hW|R$0cqdSK@X6HFo>+H`w6dZhDXrVOznp;SE8>TW^+8G^^a;^!h{L= zeE6Wj?S}yc+IrdG$HPE6`Vf!~c<+U7B|rw^5u|Tx?pmRW*n|B9;m~jSx;}(`%>|HZ z1lZY`fj=0KrK36oW}t!~kqn>$PYYn8cf#TgR1q%ou#j$z!t4yEtKoqgL$ZHO@Su$$ zHkS$TklMe3w1of@>1G@|IRv;Inf*ISGqX`no5#=a1s4WPJeq+<8oC5`+O=QGR+O$7 zqYGlZ=@#R$1u-hQ8iaJ@NLbI?3O~NjE$C|k1i#0^EN1(`?)ZYF6@4`6V(IvD(DlSw zSHg|*xwv&$BvJ|NV}YbTu!WLx@7wDBWBqDe z0R1iqfR03s3#4$>P(g-B`H6oMCg@}-F-%}y9(`n*C567TrP!Gpp@%zfHrj6@)Bq)j zgb>#1zlL_*d5>cF##WBV!@S6 zSs4?O^q4!$50B@2P(C0#KUf$udV*$W50O*{ZNJj3v~?lfa|nvxtY0s-EM}AJ*w5fN zLd2d$Vy+Q7P^tYEO`Ujs0ro3A#&i5JkSmxB5=jj$wilrQzSTw>ZrO9hRdAXeJRdt@ zkP7ZA*s%G7t(Dh)-u9Plxni5dmMb9=p3XGfe-ysl7u>KAlLTR& z3`X8_cP_SnYRiz=`hk=PTR~{@Q{btK_DN~+Ma^qKS9eH2*dNxM1D=Yiw=K5iiw|Xh za2L*JFg(&F3F%_XV!H>{Dpxv1T5-r`~UDdmJ<9Vy7-OJr7ZWp^-J=?wAt)lit?p9C1N{q08g)=Z&0nkC(p*BK~=)ZuDnGgvR zX<%a9RYo~HnJ6_pvF0G@?<(5DnZZ7(C<1$8yjCjMc7uq=%_YKSDI8`VCBFW(uV9Z5 z%FVoY{|^4xU1aPkOgX>y5n=*`QYUsYPD;4zgj-~B)iW4@>^|e;w4W^vIy9}No$*v; z{FiC%Q5aG3wf_>X1T8Vq2@!h146S{T%3m-=g4dC5rJ&qHg2CHv zKfxbROZ0a8HaJ32CN{<{=(*0VIGCq~0W0}(rVNSL@gzJRrcDIgU0<>mE6g^Ouly`A zoR`{(Kg&^42xh0U=+6@@k~_mdP)q-WBXH>0{u6KXLh4|XmHz3F7hRI@v`Qq(2I--( zNY=eheP3^vI7)=l*g+FxAnx{HWT;D*H&qbz0}l{5YOkQw#1FvER6dph1lYTM9kUfQ z<4(H3@y+luA<7Hi9tG*s{wOvAz1i*~q%~8(%7KZ?7BQU$dIc138c)%tv7M{wG})Hx z$czCBZ> z$(F6paf1QB%!Be9`}N)gSsW}sP2p{sGCS^4N`uf%2J$x%8{FiKm%h|dVnVZT(X#X< z<5)0gE-sQzQmhajFP9|woE^-2|Jke+6^peeTk#AlhXYs=r6n1 z`28{jDxDsq5A^~Z+F&UB=q!vBYMKvK{&*=H=hT~jM9d--vy)=BdoFMbWo};cZh*{K z5FAY+Ir=qKe;F!E6~t+XqcoHQR7Z*E1+ig6N&RLH^3x)AOjv$IO1+n6g~BMoYFPYeZOz0LjtH6J#q2$m%g zb|2yE)$WhB9T4-_=|{wWWA}2zF^E6NEUX_fdkgFpj%e;$tj;i(6#21RiYol0UypX! z?k6yU61K67fT71laKQKeD_8{B#;J2MDA!V|+2ZLj30weik$uG$s|NA{E8u~xtT8d% z?LU-YS2srv+Afe70B^95(U_@lL~z@9%6;~?h+0|ZIEp-He+e^6MEVuhPTHTQpnw`( z!$7>2GIk@-K@b~GJMF_k6@jd9bpk{vE~Po7!u9!2n~E;#C98 z>E=GbcsC#pB6C=c&rs{Iu}szyKR2_a9y1A3s`$ri5Xd>P5;DinH9we_RdBap?cVNR z!3`lGx~@P^TF(Z}BS+})+!qJTeXhL4W4F@DOS{a6Jmuhzad+Hw1(C@k?P?D((20@mm{`9cJRNg?u01DS zn2LmVl`M4iM}%K zK~b?Cyo{Oby3hY}6v|ER%8g7E<(nl8;!B9VnwJKV%~qu|8)icPWrX3su$y;v|K&nr zzjS;qlAFDvCZF81T*qGUR*<;L%s9#uk}l`3k|| z1vqeTMgwv>i8WWeXnKUOjSLNB+j1PH>9kN_2Yezx@!}H$nggHs0QN}=VxP2I*(d8Z z_Q_SUPoaW+^lJ859mYOYM7~U?t(CJ+1NPftYazbk=`<5>>r7|1-c0r}SFq1;75l8K zrq9R--Zgl3W0gxH7V|YmeXVCh=kb?tc!r(q^HHcH#DmU4zJ2)?)E)x?TbLobvwDo3 zBRGr+(Vc@P2v{b0)pAVrTMmFnu!2f~kZbMbGdEUk{v&U{jLXI~lIjPd4UAATO1ysRly>83qf6rSFZN3PL zXv=0gN#^3H=;ucEmtmNQ%xcVqTTjD8oB(A^EobP~8Q5()&au3KvS7CuJC=9CJiUp6 zIvg7u)0-#|nHbsYr%}EikFb$WrQ{x-I#?r!i>3h=6 zKY*+BnGxTwSnd~4h>e%UgvA$Q%k1(Zm>|fEFrtl@eaKm|@iJ}F!4YpbE)g7;k|UKI zlqkEF@!|>Vgx8@_8BOP`?3A82LSf3>c$roRmSrprAq=a<#>>9{DIFGu&tp3pYXZFe zYd~t%d3Q3Eb5(Z{$&V&uUy@Fu(tLZ!b3#b^;>_$BHl6b~eXN)HfK%ron%@bQ+kXFr zx2z4170<8me1;|xiT}U-^YHW%dw3eRrJ}AMq0XD}{WG3Zcv$^Ca6*ZHh0dQ-VnQ~LX2(=um{peG++L43dw)R@K%ac02)GMky^PYfNce(4GT*PVtb(I~ zG}Z2J+CqgOCJr3qW8($~>XtJ&X*Q>XKtvk66|U;Ph77ak-pB3?6nFyFLbV~(C23D@ zjBg(3nlT4LRS=TI{{4w5yMYtHay3L`BF^9^5)pxn4TcJPZj#qw>7H~yaPoQ`g<(<0 zxgf9e;0^gcu$3m?w|_B|;CVqg?%{r4>%kzfhkVSldmWs+T*2Lm_5x_+EjtPN`_F>x zwdQE0Rx3vme{VD{lYfnn~S2+aKhCT@n0Nx1hPfG0BkzIDB? zhvj-gh&tj0mhe3ZfaKXNxq3vYMvvs4ViC-~rVFS8XC&t-?#K8LHPMVO6=(xF&)$wV z^02O#fN%7W_c=uH;7(#*WT~NGOdOIcMKD;Psglc~cyqHfjZ?(4z9Y$>B9_Puxuqkx zYnwK*K;3=qVOh_G@C6CL*4Ax&VP3fou~8YRNwgJZ+s|9g*-;a71&jh1hmu9>%q<6~ z=i6Skla$Sf)7R{O}0 zcx|}*F}GAx(*|0Hm7;aG3cYf-$J{OG$98OgY@};MCZzXG+9%z*EwtY+9LfYZPKv@I zE$Ik>{+j5CebnJL^H3d0riOsxeB!gTTt~zFD0W=wdl=v9Y61ETVs=1>pk;mk76f?X zFs<-?xIu)QTfzgqj^bQAQGMgY#iI&rz)}8`*0Vr0yz_}%H-e1K7P#m|Z30C(w_+b= zF5LMdQ}>c}={_Q8oW8_ap+YJflIe&^YApotJ|mve%bpg01Om|pStscK99;aY4DmRc zxnci{)OssS2oc-Bhd3m?OUnFu4ufaoQxCk3dEg#lb0Q@(!UuY3DAb5`CK7nbe4GB4 zCzF&$yI5)bolI0^x$apiCr6Z1^u)7xk4z!#=Lq|%bo4i{Bb}SlkPg18T$Wz9`a$;X zId@)q@Kcnl2Pbf+-Y`n%Kr#&+i-E)YM(LOT!1ryV^t03W!u%!NdcH79-vB3~@fD-A z3FPOglSb)#uOZ@JjnYs4i7>Npdlhc~hTErr(hL+m+^Ik!i1f)@a5#z_-X_kJ*OweL z3&4@1lyEr*uXoAo{M55VdUN!0*2#KSPW1*ukka~v#4H)T>t58s5_D3%8(*8B5|Z;` zghzGx`+D$}*|L=WTrbemJ78{;PhH)>6dq7%ZFK9EEU6{wc30GlNaUE5Qpyut6-Y*G@qBQoSdA!<-D{?{7MAEfLZ7k$ce!D zrOA)U+4pbcd>)d>@$6eQIW_)>5|t8Bd=}6>8CNhqIV3PSzaT0ZFH}l^_}-U#P2PB9 z$z=8H4%*$*vH3CEIDPl0RM9r zTa+ts_=&D{@k6g;{nu&`Zb;Jaqe0j~k0NLTKU8e-x%f5+=C?&_>go^51R)nhksx8( z$t_g+LIWUr?8W!tU3T$(mc0Z?`*~48Bp2WJdSi_%CckFHNfR;^3eJk=D!8vu@Wb}C zC^TPn-($1KPO*X?LBT&`1@~tK_j46oCKTLPD0rQFp4Q~h9}zZ=WAmNFdgjtQE0pJ@ zp@gRk^ z>^-?w=}*rQLh*A;3CVB3yhoE3XhsS51-cAbKCGR>ln>Ny!HDiL&sa)idKNu&vc@L`&H zeSu#o;cf$8#}@71pY#BMOf$1JnWI@xI`$X%PJ5Gup@sbj2POg? zSBzZ^PD-!a@G?CGI@+`wFYdQgEg~y|IU^rfZhD-2cag7^`SJfQ0C!`m112S9W6)P8sEM-I#1 zxgTIxzj~_Ohl>F=eHr9AN09Ku+_{q?j!kS3LkoOq?!#o`Hh^zpi}uVs5IijvTr6tB zsZk=%ikDTzfa5H-3dP387h2#IDrR-`5iEu82iiV87h4_JEVb9l<|6SbWBfiZ!rzWX#ToFNj6MJh z@4T1LrPFz{%UR`j0D?wR*C-5{ypwrh=)Px-R@caO7O$7dqLPP^`-Z63B7L;(>qo~ z@8m0JBjY{GgJ3b&S`?0V1VSjwbwUURG zWFI???VoAy1_UL}+@0k4@Cw+by=8b)xu?DTm@f@UxnOD+S9MHaPfrOujVRu3XDeY_ zq4y=&Cuc(rMMM!HKpT+ZIG&IhTn@!Z+DPq{ z=)dS~29C+z)5$xcIzanFBX-Nf6z@DFrRJB%JX2W7d7iK(fo8r1O)1#^G11b2JB@LO zKEW?qR1Be8&nnBJPi0rasH*LfyKzii#djF3wR`B+qw;TObh&(*lx3-6YCS;3O?$1 z?P;4Am=%_2FD;q24Tx<85?h(CB@?Nr&ZRn}$rFn_AV!?rfK4j%isWAUEKk-i@)DV^ zg(E&baP-19lRY^CWwO5JVPl55MS{cn3qDYpiaggvwfj^>A6b~MD@$xAK*tE$4>y^= z<|(8BA&qnOb-%-!M`Skg^%qZjQ{Abd;VzPxi|8XW=R_ZodK|?;Ae8yi0tol<%q+5A zT4V{^Nno=cmhcg2!SFD-d_E;NUuQim=bh0Yyfb8(j!XeOcoMv~Asj7|F^>50QHBBX z3Q!ge5bT<~65Q^^T}D*M9KVbrjk7L{Q$p?oy&65LE+GR#gmC5(XF#znn_hq4u*0X+A!v$>8U$7c3fzxMsC>jeoZlh`A;fiB< z8mz!gj^**ZflelbqXy!+yArKE8;y}Zd1Q*mg%y{UwucOS|D z#=zGsKKqK{Id?5w7cX6wL#!pBiERvvUOZNBW9YMvV8Ldd>#WH%Q(?1!O)R-60tO9D zJf?Vb2*+|gT&9?r0|uczpC@X*aDdOzDiMRZg1b)zJ}a_$!Zx)x4UwkGD)xu2@{v79 zFU@BI->EDd(D9GEcy(ubHU|*0siCU zzn%PNFekDFk;|XrcaeV@`A>YSzmEL<;^6<_H~g<4zS`wK@(q8=f2qsA;T!%G|DT*Q z|Fm!TQ~Xz4{&JVU?%Ztr4)jz^Ad|kcYNyeE_BN+6ZT5RkW8ti?(^xg@;WW0)4nBYs zoRFlPnklCls_8R8&HU1lhZp4|nbkhbvfManhK&5|o?i;K5wiWxX}gDPzjWHRlWp8- zdxUJ^j|lO$fn{&D&*`^=Y|T#FF0z$7ZBLOc$7!1&TY}Se0mrJdcBf6g0=8G2wj{DS zoVKUP_NmkM;7zc72Du#oapUA(vT2>R<79iwX`}nhW{)^+7s&SehlF^hP}p8k0!>gV zXUX!cr*p#D+bBu*HocbuKTmD?0Z#vfHf7-tV_ur|bQbSLihbtiLbcXn z@|fM^swCMCJN-t;_LzG<=TN9X%15t3K6lLLK_Oxr{d#|ysO3|jfZ#0 zzlBO1@eP0Kr7w_wQat=+-|(mOe?|V=DE>Kc{_y?R2@&#NPyT6%@IU$uf6Bks6@T|P z{3(7i`Jbiyw|%SsP2?{oNc4WgpCI+s8Td1NqIdaU)$BU}`323+A>LmoUK-WQ-x<#Z zUl#ui-)&~}+}f+-pFsREihqvEbpnUi&Zz7=uH$C8pSkrM>SpB>emB)~*VW-&?RggA z)D&(9r90vb=klleE+zk$li=Ur^1rISkM9)ft2;B>K;_V#A-q=ZH2TlxJB?|xsZL|z zY>d-bH5=?Sw#+_2J=NLbGbn-m?Qay5A5e1O%JT8=s zzEk@SQz`u2OR<*+=o7BQc2Qzkl-QTpz1hia;q#~OlwkYnVP{C@++x%ns9SuH%&GZ0#@<`U@TKZXp{Vimk+! z)@;qyvDx~f-C;`e!y%PE6YaV)2o^`oZpT{?VGwJW-@1=? z#-no|(q5rElu)bd_)@U2aP{O}ujH}1?p%Qs;OfP@eki!gcvmchD21cEs~cRP$K#v) zsQ(S#{un6>;640}bmvq3AK-n-c2#;o|24hdd3b-b|8-v7ekXEy7_H?!Kt52%1V9c5 z9(n*8H3GFDc>IR|ix-tiG#i-&%9pYjoH$FmF1GkA{Tx%9q|=ro>ReBdKW!Bc~$8_x}R zM)9men5XbviRUOD`kg_#6?i7_?8fs5p8N1*;fcVr0?%SRUm$KbzN2_v$J2m^#YcG# z;kn^mgvXPO=WW=J;&~p=6L@yv`7xdmJYVCXUlqRDg8B9Lc(;}K-iGJZ8Qz`^vmQ@7 zo>4px;Mt330?$E&`4Hc?@vtB4zIblN6OX3`&mf);@jQlSFPIp%E}?kX?>XAQ``>;^mhO)3o}um( z1Xm4!nQ>%9gVRCqCV$)STspb_G{R>nwDH=1JzH|k&%gg-m(RTy+IwRkZJvGj{+0)# zww${5k-evHzj^j=Gh0r+{ieV)*{<;(|P&s_T0XGpS_#D ze{}uvw|_8q=AEvRr;lHl9(%)DvAy&9iCrBncU*4z>g*B2-NkD?{7!Z*YHm)Je(~?6 zlJUdxZcUx6t?*2G!{7S*S|2)g#w#i3xVYe}v8AtfJiYkQFLpg0+qwOTj5m)wcPj1j z^N;_%^F)+o?R(nSmcDtqI{Db|ACEX0kSKb$WTfP+!#6Y@J@E8}r*2ie_+-V;?|=3+ z>7y^~ePFL=kYtN@{SzmB4=HDt{CV@bp73RbrmElH)Hs=}Ha@d0{q*3XzEd90%U|EV zQuen`Y-4}!yXEO;7Cn0Az^|i^@8upk;xim`88S7yuKB6|_G{mNZfW}lb#j;FXPqrS z@>tva;f0cpj;6-W6(=GLV@0B-^Z&emQRfdI^|*2Jg5<8s7p4C`baJ;rKfC9;kN57k zuiLWk%6m7x)0C%vd--SU-nhq5c>K$%#wT>ImOPzk7Cry)2NBO5Pk;2i{I~8uk=*s- zu}8kV@a7xsvu&AIPIkv+Z)yF*(Y+0C52(di|G3F3y1sDnV@K94eJ82UTmM+PXP`{B zWdA0)?-AA0rphPBdgRv}H}3oOnZ{SIz5H(7_9G{QZ`*!!_fxyxn*Lt$lhqrSJ{6`} z`@)_-bUuq~!1w<1nI{kY!uNw`yngZepUnw5fBX1PL$Cj8dB7>L^@h^}*DY!O`>3Yn zzLfT^rMqg{?^yEMwP$|ixaKE;e-thL^8-HXvwk8y_xi(<&8G7nH-CL_QCn?g)5X8G z8bUD=*4+)wdw;?>HR~#FMH)Id2Zhgp0|Yuc$e?j zJo}fRB`-Yj>J#O+V6{jKAzgORTtecJxO$_}a8?c7+aPyh9mBJaEM58Ur}$KDVA81m;I#^3mi?=QE${^OwBk`9Dn_dO&K2?|Mb$6@0hx+Z{PCD4f{8)3E21f`$M~XhI01!e^?{g(%UX|yrfxV zT)V_$nd1S&y={MNy7Y#lqfz@>=MBRjEPn7`uP=RTwN+en@JX+P#(>t}Uc8~!N`{O|tqz;o|zcI1DO6=8Q6pWK_@_@d{HrrP^LdRE5mU-Hz>t-ez? zzUN&t{)s0YG1G1f`;nPw96D@px`P|gWhNx#3N;t}sDvW^5t3+#}q~F@l-$ zig$BQb2DcNW(t$*X4bofX>c=}+{~SB=3Y0m+08sGm?`~HH}gF(D-;=x%^j`%J(lhk zSYglZ={L;V+qzmUZDDQQZSZ5}`p%x#F!L~_uh11&Xz`5%?24kb8 z69IC21`Yj&mb{ikdBm_PBA!lR^!l(M2!Tb5U&6)7@{3k%cr zWmGOjW??ZIR>Hj6z>3ViS#1N2O`Qf-Uq0Q8Rs<1cn%X*BVAS{YT6*!#=;?1U^oxXV znW>SL0J7Enja>%#3typ{F8B0ibK9VS@@zAAQaIszwR>hyXJ=#Y0ACIr&QmiQ`w<$v z0?qyKYGO8*Ij6s|$=#3auAJTCkh_pmrpeIUp=<2#pm?2as0*LSyxCPGQHI5A?&(Hd z*>^r+-aa2L*U-pd!hh$(@%H&}Wrp6y{zh{Tz$bE<=Y!9?2~kQ718sL0a{AlQiRaDp z5$4_I^H>dt;Bf_l+2sjydAG5r*&@K#-R=ye@9Z%b;s6_@gUDrerN+DEwhfqjTG8M_ z7?<5G9QCa-L#LtHY@qHV%Ia@y&Fb&zUESE)zM$)AY3$@fJDo)3JlTV>y1J*Q)7;jJu@HsctWZ!d;w=gV>%}xmX!whU*!Zb$ z?!hTNjfBCTww8IDNEF0^2U8l2ZQVj|M7$uf%Da%R933)P6ja`Arf%I5O!+C?i(Cj$ zi4=)7^(~F&M%a)i#g?mLTIA;bw#M$(PAU>w zoscjBHv@$A{phUnAXQ9Q1Ykt(VD$ofCJ=6g?up|!2Mm}b|?HnXX%n*m~& z^)-s$+iPg-M>Y7sxos^ihHf&;gEAYt%R1V6$qXY64Kxg33%5M8p$jm_um+S08wbpJ zEke(TuL|Yqk5D=Dy4}#v7g5(Z(194#ah&Zc#ATp^nID`8LxUOiQjD8YL+6@^+67JN z*3jP!msHf#ZJ;%3X-|)tPY~_Uh|%n_32nf8@_0k&_ZVS9?{oIq0Z|#I)y7tICP1O- zb~Bs5tu9zRkIvH=4rAlKwF;Im1Aj>>kPmd z%?Mv?0RpGmBA&}k*teIbSMs{MUH;5WenR-lp8gKOi1Ew1xKJnFT#DB3>E=VY<;`G> zwg(m1Xhr}zIyBXjACp}J;YOmn_<ux+3Xl;8q?Al4qf090salkgqJg_vD!!p4(e}$=R6?VT+D?wfbEVI><$x#;pzH5$?353f8_ggtsZXJJ7}vl8_@ZypQ((BApB`b( z0knD>G0O?0ihEv8xA`u~m%-^ik8Z>Hp+jJgGRg-G%@}U!0MSq};12qgdLb1AKORQ^ z*P>$VGJ-)EVy-k66c%agdIo_I7P_L23mjmd&wPHYvl5aYVNUnl;Kmo3La^`^e18z? zpY8lDk66L=11h(zb`Y{(Re zZpgw2#B&Fpk^RsEvmap(Aio2!<6*xUhvSoJggGqO-996(vYe70fqCBUflxR^6nP4v z$xLqabGprkr+ChXLhxpS4G$l8KamJ4-1=Hn2Col<2~T(scf) zuDt!sUw@hgGuanBd>)h!B}vc1UtDc4NPPO4DkAy@0>fci6CA2ggm)$?6(y@u6pGk2 z-7!%q&Fa;;4eFE>MYtg)GP0di_iYzovQWcD|&GPhQB6;v3?qnfi~v^~+K;ZZA7 zYMX*|nHpug-dG)`G1WEXRq7Iw3QbX~JIg|h>H%fXs*MqaB)3oQ7rMG2Q>cUD_c9f@OCgzHLJ^sz z%*-=tDgzb0mF4=XV#{!qr93D%K^GL6)Tb`jMn@{@)D?m8d8Oq&aV5sE@WPbj0)tW+ z7@MsMu8pWuL{z1fhczbkCzceNvj+;B3s)%=oyG0Jim>X~Bz0*(L2KbqU%s)hwJ1PS zlG>VAr^u>~vJ|$Z)%EK-6U@oYm3@dYWN1xMW@ofll&mhxYSk8W=at22bqOgotdNBo zw2^K&AVxQ64i7I}qw7dlRHk(ngcSv@iBQCq7S;zShC;Gcx#pY%ouaC+p(r3MG)EVs zZ`G)ix(l^MrorJ9b;W=#Oc&9QvgAe?R_hv8_T=kwOEVjaI*e^yx~TlnN_BfxSz>U1 z#881EExXmAEKg||3M`7tQ79G0424o#r&J^+B$_%x48;budev}ncHBy>Dm8AEsxC*D zYtUD!YhpVC19IB370QIzRf+v&sV(UWV_QLDaCLu3Lx3WpJuNV+DJMWtr_|?!6?TSX z6*VSRW$FsF6)TH^3yZ>wRyHN8N>=r@HL9yxQ)UXbD}~s zlo`gX=&F?iy|IeUP-Us2cDTMOa=4&M)f8L4a!r41o6cC?lThAJl#pP`2{w0ygqIH_ z^yUOt=`9UO5d-Sr%GKte*38o3yjGy^0i!9o!>lXlj&2W5T9wokTh>t@9uZVmo8DNY z2dNfy@S4P8Q&8q`l(Mr(+f!6$2v%ff zSEr@rX)=mSRt}U7)tGCBOPkB%ES0M=t9pha+JaJ*C2N}7i(A&{V_Jf1Q%Z~V#l6F; zi{r}7Lv4|XiESB?eZiUa$t@L8tMWBbp|x>6y~MVzv)PSsg5WVYm1*CuCG zg?2|5DkAi`S;aBNgp`)dwBnT93`>E&SHDslS`^X*-_G9Ba9#guZEjdzdPzrEV@lSV zFoUM6Ic&H#uQyDeTNfDK*jHX0u8gc4F6^m{SkqRRo>a106PsI*6_VCh5?E9c6kV?` zG-+evOT+rG**H`Z5nfr4S`)fvI8~jmX)jq_nU3*OkRMcE9bcqQ4A;fQB!;VNdJFo? z2L@7G6fHGjYkIRiI zNmx^(YVID?=wS`IfaZRNwQ(6ZT z*Tm`aqB?@Z0;7VIvDroX0BuQ7XmELLWo?Mj6d4~jIMCP@5fQA(icX8^u*B+9v-I(e z`Q{K!U%9R}Iix8tK26hA(Uws#9Fe76qi(e1bjBy@^8>QlLv*W(Gi!_Mf`Sx^+J=a> z;FkW?8g*P%L$W$IdQDqvdAB}CT~yQA6Q<}$Gbxgb`#Y3fDUB&gb?WLaWqCzVszSf2 zx>~`I{;(mgFDx#)KQDS^uO97`GLR5l8Jgd(iz_Rt4GfRTR17N18zK}HVQV5%hD!!= zl}2rsUe^i)6<1&i%25rpmSrR-s{`{4;U%lhIjQQfm32kxn2himU43+QXGvyUP;Xpca6oNP!>an`U}gBq z{KB9@bzM-cawt#N(4sdNx8$UUmPaQJMd{QLK)$tw^{I8ik%L2lVWGOxfxe3VutH5^ zQGg;`+nOJ&&uCtwHl~DB_H9?XGI=)OJS} zsGGXA#SN{NY;#bvDp`}>RbMiY)?V1tlNV4_rKycjw8tp2BV#nJo$>0NlHS%KQ-5E4 zU~*@@QQZ`i5LjM}{%46(D-=CI--SVDLx`@~6wq2&ZO#wXY0W^YroiDqU9vK>OkGo> z($~f})ubrOQqdHul7POz=(_BofYhwu@~oo%o@QNidfck;@Seg{g((hM#;)nB3@^$m z?odUpYHQboBt|v{wiV^IG^u+m@nQOvL!pDQ3T>Wpb!AzKzQ?RCU6~uGF4Oj=C$uf}}!KW0Y3i+Fx0ri%yG5R(C{2nG0)UlnTYFN<(0Ld46Vrc1=rt zvT7(#6S%5Moik8a71Lf<)|!tXrBptBG-i#qw#op-N>g1{Kxt}wZ(K;YB|s6Bu2(3k z%Hx}r#4b$&u@y*jIRO>4qXb8&z|r#3|vH|KXYt5**84n+)?1A7;jWET`wrIq9b z=Jn`%q8N3{W)F6c{uRSrstcrL0zE#H}ny zG-RbmM@6?MB*f=bHKi+hhjat#_SP(ALP=g(hC01IsIe$!xF=gzmzEhDpA`{O64Dpl z9ifOWkId`NYR_I3AEhp9*Hz^g1P7UvreRBCeL=0IGa*V9m{D9FpvWjKHK_+WTjL9| zI{OnjJujfr9D8dY_9VSARot1zjsdLX_{Q8kobT-{ipFKCW5B?cxG7(!cvn}S2* z;*;~D6EZZzZPm)A)|?@AKv+#%LSA=OmZiE;m9x?qmC+a1)tykM=#3m4R4IZg+tixy znpjhhMiG^$QMCjph7$%?#b?I0rgodFBC3LWS2t)>y&2Jn)|yik9IXn{$9J!8i7kxF zF{FbQN()itM_Zy2gQ|@w26KZ!6Kqrzbj1gRWMwMzVn7cT^w-u})N7Ix63pg-$gsX9 zbdadl$jbcU_{hExLs4Kvbf7_(5)fH6T&-?y)OHuQtD?H&gM&j;^9oC2>%#Jyx|7sZ zYF%I4n#TC3!oI|8w2UF7EMaIMvtT8V@TvrDykRIX*HCLp9LQS}Rj5<0X|;4TM%R?K ztV%Si@^TV2N>z1ReqvEya;hPHNE4pe-JR7J5tLcotiu%CS6D>dF(5ywU0L2+kW>=W z7+I^c^j6lX2iohEsx`RxZ#vPqv+*t$|x5Z~DyG}LU24iC(#R4c@2P$<*`Q3eS2^9nRmEm2LWh?dN zZU2Y0H;ZvCNzcT1tLoNrYw0RgFH)=3&91|JUow+BnOu^YOfI>Q%vHH?CzES($;{gr z%t$a~z#D{t4H$;)(HM=H2Sd;dFn-XR4Lx{ZVEkarg8;)176b?e=E3t~0Up4Xzc1n( zl6mj#s)i-r%RDFIM8yBczr`Pa#9`bAwjx*VQt>93Ip4a^8TXCe+%9G!)ewZCQ9m4B*zCg za83{WBZoP*w`pn3_d2#)`*ET35RYwCgPldjkTYh&r*Y?W^TcMnvz>c}w-0p^{w`V#IPL5$6^LInzVshf`gljiSbsESnl8R-1+~ou&Z{JS% zqt4*aV>sLyMfStf?p7kVwSes2J{GIy-n23C6lyy+2lGL(Zt^Ny6_=9Dp0H@p6uz;F_X_G(9W2ivZGp%Z!Xr#yrENno$-xV~snNw(dM&0ukC z@kjcjiN|P71`^Iwdn;!i2d(w!C_jSb8VA#{^Z4XG75DU7rn~ONWujL&-rl}RJ|vyJ zqqHT~pB-NupG*R`u9&?vNu`a`uE~FO91fmkhC7?rC&2^DQ#4xJb$d$&C3|M@oNS(N zJ(+7eaL{swz>{(3_95y_oja^XXX0?ywha=-wBI!>T4L^^C%pf(Yfc1CyL-m5xdx_q zI-XMMX?$SW-HSGhS0k6*c)xwOmuS1Hvwh!gXJ*=nI$Ik7Q+{A?yWOGf+qymBsuU!WAjSoA((f+x^QU&p_4M>Cv3YtE>{x4-p(!6cj4Sow@HAcQ_f1OW_%`j>Y{om* zY-H}(2yfpEg1hd`?#4s4X*3x_o1XB=S;llG(+BsXIiI;L9B$_7dy#47BtG&tcJjfhQa`&I zINc}q>%pBr@<5Hc+&n)DDw9_KEVO^q3qte#s~%@+>aWxPJ!Y@c0+vxmvksdMN8$Y@kmA1^mMFq2WZ)LM%T@)U|!GOOy zsT4YUb|u@H?3r)I-aycE*bU}~Pe=PfWe@0XYzMZ2+m)f|sJoF)xi=3UhDnp-$aGY% zj(djMjnQB9c=xOuPl4REDSvd*nP*2Q_Q>U7BYrvD=)2vHD{n%%JvqPJpW6H;(`<0u zF7!??#$P33d4Ksac4>$$j#CN$Q-344U2Aos7v`uz+1RsgIpQtPU1iIR>G-|Tbr4JV z%2x}U1p;>x+&5di*4?Yitzh@muxY-(+)bM{?`|tQiJ`eQ%kGwri`F|wyM2Mk(^D|w zjCVHXws1Ok=)OFvO#<$aS+RI$wQ=Cl>AEjfoBe(3JPk^wt|L#o4*-c}-fdSJP%m z-8x6XOlX{sRwq{t!K-id7md2IBj)co@8Cw+ZL%JMP(tFu>Ww3i{ zu3Ibjfs;z;{@QkJFu1~|()PB&WIf%R9}aDsH`4=;sb$QY6sO;FXW7|M%olan*lnpy zhK6|F+}^%Ce8>(Q-FB{2DOI-?X3qqiF`iW?p{q@d#NFHAP3+_xqTCv|N|o{q6Si6- zyYQ#XgQN1oJ=}60+_#3oihaD}bQ(N0cmHZ}7utE8?Z%A{tz%pF;X0L_9NmTUW~IFE zn5CR%<;sGAxfAkDE00dw$hhr}_(Rj_e%3Ki?oW&d(|M|u-f}x4_bGp?UOK%@IQH)E zdT%4Q2_DtTP$AQ{E%bPpun)$8dScsX?r+>qJQoI^&zSeyd+Ce2#Mypn zqck+x&tVC-ou>xO;&zVQ4hI5*)=adk+*-SyaP(*^FwU5X)l?-%iqmf`KbFTU$I$Jj#B8%f7PEhyuP`4(y5$S3J=bC;qs|-V~iDV z?gO>!r$nGyZ^jj4uyL-OUnF9V+tcRL!d+`2?6_q;4u`R++U4-wY^~46fO7aY4^Ru(h5IBoONaE(omXbE`l5T zEnmL$fC%Z~W@3KiAI&YEW(=|+;>82M-)@QA`wPy;Sg?6!P)@U^MQ(rFS#Rg!#_&zg zm)cCvj)SJqg-MAG;b#p!?c1oSVLd8rF7_3;QG@+Ed&W79q{is}MrK?N1-h`nJIXk0 zDsMctGFeCHdT-pi?b-_Vo0_dOEu1>NlieGWui8unw_3)OI~3 zM#AJO<`ad(;K>sL*q29V4dc=NL&)c{Wa_q*wSzy!P_t<3?iZ6|Tf?N(JrA+NyVmr| z(AhQZpJm$4xVb!ks0KDYn}d)cnSJP-A7dbhUe~vRi96*!bab{+E}D-I6w|EW%@th? zU{{lOKA-ohiA|KJv0>1^*o>I#=T8n>dEn_5ET;$%H^(W{fxB`Pwp?64rJ991*sD=5 zVm6<-ZVgJ%?%mCV`-b!C>8w5qjyv70>C=VpB6MXOHSO^ecnsAWh;7&II|`=nJiYK% zcVaT6-QkI4FCVW2&o4WBM;o^rR$nfJ+{XNAKD_D4UE7D|hu*C}VZ4~wqt2$?P;izX!rQK~H#9QLJSKk#t}mKNmG5l^ z|LJ(YoGv`JPA+Q~=HgNA?jRb7oH@@TCVR73cvvXc)!FV&I&`|zxID8w<^l>hp7q?F z*jg8uRvkU~_ni&<{$_G8g;s!MTfxG^PSPyGEJMfTtu2_HTeFSx&d#EFl|F3`w}K8! zt&lWq?_?{T!r3@=@2(yWCV_DC(jA%J^qykj3OvEhJ!d^y$eH%eE%{hiv0fGWhP-!U zaMB)zpA36Z|Mk%zTD&zJbZe8;sK1z)GfKg5SiiX~**aIgR^-f`nRguZ*_|n`_%5B{ z-ucvg^Vr$5ma4hqV9h&X%&v83?gpXgH5O9VQV*M zcnVjdCiCuOv)YbtW1_i_2!?a|;0u|HSHb%tt?0yI4hFY+wRCK+Zad!}=l30!J7Ye! zcbj)Tg!Vd}`&6z67yIZTg^5$l>RI%sixZQ}>W^8jy|-iA;T?SVXsu+iTn8*><$_By zo4aS*fyEVwSiauyhy4EJ#&p2s!A81M*cn_s7`#XRWGm|rH0x)5hs*kKr#zXPw~_l! z{pi@3J$3jjiNZl_W-K>gUQ35&MM;k5gWyvvwWHj5s~O9s-%zw%Rdc?=ng4i_FKtKM zO55Can{I}4Q`UOc%tk}=4eL?OW$RZ8k4I)prIHG{p7zXGsM@!83ilyStM(Qbhb7O| zBHRtQDlQjeJXle=vs3~wv~$KIM(2a5^sn|#0!L2MS@X&0tvR~sm}g<%8_eJwFLFl( z=Vr8&u$EF~>ru&elXE0YR-ZXnG#30h>zT#UayJJ)Q_vhOhOd>P?Z|#vafw;NdD;J9 zY-exb28~@ z;y3Z_{@KyISZlO1uA%cJSr0~X$E~8@@Ywd4&E09uHX9=jV$MxW56810;>^Y4^YX+P zo`<`e_vOyxWM^tf#g813nI)|lthcj=qeT|;3TFnZxsDF}YTsog;yNogOQEBdbvl{5 zZt_lL^D%3kk*gCW?P(aDyLDr?3AMj7CwsOhlWDKmuUw_g2ju})f{%AE_s?p3rAX6^ zng5gPrW$eG9#*$47l;>cOud`F?eK%ceC#UUnI9ET)EVg?=B(NFzDY@* zdozzGY)@`n2A=veS7BP}drUjl$6Vn&yX`BOJ*B$AK6!{*d@f92+}Y{5scX3Q_e|UN zUE_Ym9CbP#ZvBxPYc5p0PVQW#ONsQrm%QlMjT^nnq~ec`oF?O*u^!E4?tH~)cQ0nz z=|+8p*2qw|)hcH(XYlB$WbJz~s(BmNcgD~xT8Ngi<*_xD0Jki=PqVD!+PTx+Hf%J{ zx+Q~MnLg!%=DU_T6X-LH>zkZE9wyBctn)_1aUUScm^ly>0~smS~g5U_n|%9EtK=nqpI<0BQ!VX!qZN%XU-P3Yhlm1 zbCJCChs+MkLw$&uXw?{XmXEWym3eq`!*_gha$=ZlUrvIVlgp$d;YA!SdkTwGY0@ku zyUs0BXpZ2;pnGNVmM6Q#`*@}2J+SR@F`^K>yg4+wit&eQr`39YP_bn<)Ayd+^On(W zNNx4Pfo)IjELyTx?4IJFm^wVNo!rICvrM$QvA=g7>}PydU%ToqD%fvet!y}MVi@;( z!%GunyxPy3olgj%gvH8P)G)~wZ+p>%@zgTh&FmG8@!shnRQK@K=q^NCXT9+DMJVkG zjAPrD$yqab;4T%8f`h|>eedw#s1|(81Y_5`gTq>|lFxb5cimaKQZDQl&F<4d+*!8V zKN@Fk_qI_b>iO#4bsZUREoZTWeLFd{?ZZ`w z`RkbAUs3(WrI~pPV;p|8IWc#eZ>pQ2?JIIYDd10wOgUJT+#8$I^Qg11ZBp#*VSFnT zE7Tnajf)evHBzYzgD1I2!gw&>k6P**L&Pn%!iz-y7iIP33Ncax|0ljLzD7Ck;#1R90SLBx5PyfV7&?O8K2P|CG-#oe}@UU^~%W`m_t zk6v1B+pR!g^Vk_aAJ>f?TYO*(KOH8{>#j|!@$n{?2rT-W`)PZ&Y#Ay&bKhmIVF@-A z4b;u;nRzqRy*Jo4tKA1!*4}l{-p%c#vbUp$@omIB@VKta-l+4jn)kWWdv`I28XqmEec#h?vT?MX zQ*t3k1{1}A^DyRe-h|KhuWIG(lf;%SZLu~F;8mR#9CefbxZ`#;hQ*L+3R7T-yDpqL z)4t`%v)9}_G6vFPXZ_aMh?Xo{)9u~_%LvnabQs(^%FVkr1v8+7)P2uh2s~zXoVjT* ze`y}tGnsPXF>i9a63!E26|tT0eZI6X++ZHy>`wxvnuwbn9p=yPFSp}|)^09hy8))R z$Ms9sUGV0}9W})l3;PMyqG!cWC234pEf2%}pvUSs4D7_M^Sg`@GU1#n?fj+j_91o@ zjAq-Vey4Li&edx`Ea*O(8?vTw-sZHF+-AG?p_p-}e-+@14QS@a7`n84nJ<=}@_5+PiF;8iw)ssCsv`^VGEYFN&D9@1FX& z89wE_fhjOn2Vuo+=0YSUIaowGDw*S#M#F_+k=>dkxAHyT!Dcx4XnQz>TzPLVcO6#e zP>FkP5x{BH6_>wfMT}v~YZ;pji8FsH>OKy6BCU%nW2tc;aaIObN;d90YR|80t((nx zz7Q%_TcNsbR@gZTZKh4PvE9UW@h1ZuoXP_ju3_n6A7% zbJ^of*>@h?rCLJ?l_RkThV0JGR`u4_KRNe@p7M@M_g3;Q5H@>LL+6cm=e%9>+Q+8x zMt2g(mu`+M2ZP*ryKIcyois-tvp0Iu*!0B~xBly~bL2I5HXb&Edv~U-n|T24LZS#6 z$I|H0jk$bou{fWwwta4KOw4b{b5SuEutYZPG~_ z-Qenpa}nK}IQ-kK>rgf2-M82JA!nuJ9(MDG9eZ;BylE&79+KIcJ1lIv4zPh?%U^32 zE6(_-vDbPm2T!+#zUe$Y8JmyG-s9j#Y=eSA*l={gH2+3_doF(-+r)M|bJ28%elk^RvW}H(vJMZ=^;BYaTK*-EG1Wo?;(G z!%zi0sEzcs4yQ2^m(R+7~#%#fU;mM9%)lg*GD&Je{ z!<^q&jm0*Tg$3ezCvC4k6m(Bc#$H>)X{nuiw}Rv7?f$G>?>ik{Z03u5!Uxsb%;FCR zFG3)3xt$HR>am715-%S<23%X+k$-p_x<2cVEK}Eg`O*`q7)?iwn7v#%emXPXdsC&p z-(+hod=XRd-e7u)A1OzH>q^_c6}2>t7bn9zUp>>qJ1GU<$i8uEHXQacnO$qgF*Vu~ z4#Re0Fbu}^^}gcG26-RoNSdUSxglSgWyKV z`pZ$!yaa1o~Pc8 z>GD3iZwUnMZcO{9;NLV=9GAx!t+L0q{3fD)xAjwJVx!c$F>NjXjBfi=r?R`> zC~loa7V?k9RdczneU*N}I6k&0k%g;bY$vD2jro4i6pwnbfAZqSJ`A~)J#Y56 z2X(^L`isX$qjKZiFe(1)d!5br zuFq?Fu=qFQC%0Hn4ri~vsYBVS zyPQho@p4b;9nF)<@Y<77?(b45W${qKnwqnlQp_PkTCwkJr4{$lUK%~RNGpN6VOohi zSTjn(5zQ!RY^GIqGqsG8Kb&QhgDdxr((xuYm3-3XRXS;JKq>AvBTCTX@hJso)2~cV ziyO*br{+~0QS7{}xbC9LfnxS4>GP6TxvyP^m79&BUm0(^V@hi`7*poK{Y~Z89tbKM zi=0y#`cpoooVpAuN1pAV(z~>Ul-|K8sCY}mh;ltEg_QelG^B)MPfq19lJ_YF<5@_l zr|mA~xD$yg!&1zp6f0RIFAiLaFJawK&J~LryQ95sr5-7`m1eT)hBQ4yl)<^dql|8y z9%a_v!WN^fZ$o*U?s*iWy9MlrnW$piFBh}egC9;;Qafk4aJ1F+br4ebcYW8p{$50B z`tLGv>qftLoAgBkrNU2xR5~5=r89-IVtS`K@1@%& zPseATmlB7&m5ub@>W}lj)lc8LLj9f2wLNR-Kc4im`<0YwGyiw;XY9C+I(@;5ocSOT zd7AvK|3m`!PGwLy&xM~JGBJg_;$1E$Uyl?Y=b8M7oHJ&vp6T@>Ll)F)CDr8flIyML z&(^9vhlRK3U9K}iICHVk8Z4QiHtsx=CDr7cC6}$B8PSd`=X9>xBepJlk;AqCZ1qgd zcm`_?<+YNsvc&i~tT)OF?41G>fh}RZ(GStD^{T6q#6}<{>f&xyY@ME>KX{~42*os5 z64a_5OFSd$Ggx?{)qM_Y4ekn-O3W23En`K)Ghn|$c^ww>@m=<7*`0O3OIU&oY)I?Z zGGhsgPuGF1O3GZpbwN!+kl=8)MDJI?(h7=R$b{PR8n7j-WuC|(Ao(A)2}=X^ZdhvN zXBVyIWy4DfypgklB?!9$_D)zVP0B4{F{#1Qa+f(PP(t6?mDPXTErGoY7N3LM_-Gfx zUcyp=fjfe@YoLTQqn7$1L@hzw-vLW|tW}ZMrF^RW1qf)to07@8>-CqgRLTg%h_%E} zYW27EOO!;L@6xz+K!m$WgEA_m)?o>X1GWlWO|EDto~W>h@9HC{v`&vTSQ0nFe+Fv> zWKBfYVF_$Szfg4rN^;~~umqX3k>WWlby$!@RTFElBw%e3yYrsUmP+TAcn=e1W zPUF`SQ5BXd)VE$)b`6*+rf&34zehHK{$ZYy8nyam8Sgts!c1+-- z>a^gY23-s1%R*>v?W1-} zmJ*#hulpNT z5m&Fb;nn@|fBolLTBjfDb)LWR{9Etecy)jCfBucG^w0iC6vo@T@993kU-|DnT;E3y zbNN^M_fpM!A5ZywRfnbc^nFo>^;k#y%j>H3m-rnUKKoic=d<)R&CDK1sc`EC(_wr8G{0x|q62F0Rl3INJ zCBE$EE8X`*Y2wJI@~^B(=*;_2V54!IP+tM6Caa$aEF~4bMoIQp>j`NfC0h1@*lJj^ zo%J@gCz2W(U$rvCgl&DitWWstiNu6FB}KkKsSok*Q}p-+`o^b}4N^rym$YT6FYuH! zeyRHbt{*`nRvPjFYW+k!C7x{ch3?15v4N8o)Y;G-pxzg{uS6T~329-QghzV+2sK{f zj`GU3C9YD(*lYfKiT2pPj|6OD_dEE01vqTu14t)n`6=4sGq(P@?l-|XYS1g)Z|M}# zE_?94=nE-8+7luvB`M6OQr=#mKH*B)Vz0hHY34{-Wi95uFQoM= z*fv}E3h;jbiv2{FM~PR!yn|egpDZO)?*n7jSaJI~4<-Ld1!BIE4-I2-j`{5SCqimj zR?41~Psv+CpyYgxuLh0fBz4#ZrI^~s9!jh70y;rBRzp(rQr-s7sROvL;*pO7NRp*Q7|c zOsn}46#5i32#I|m-k%`%Bizd`p%7=5VGYuQ(ku1uHw9kQgwK&f`921m81A%sgiE_3 zHJsd%ZD}R=gn5!eGMDH8jJjkV=y_C8vtc2Xlh$Gyaa z)`OP*d-zA_gvWmBp?yErxlxyGN={OenIf+!7nB3`?`zbgTuI6@M^cv0`Hz&QcFT4o z{n#gITS;>%l^;N+q%II+_MiQeJ)tG!os{#Bfh}wQ2zhaoloH6&gf1;2MkBle8)B<&ULljI8Fe}sGd#LrPKBX04 z-`ToEi~OLp$-Wc%m&nnJoUefcwOLa33zU;R_z+x`eiU_;G?jju z~y&orq= z`6QPKnNs*ujFqg5-x&vee~w)00;QI1kpi^6v?HJ4-V09nL6iR&U$!avM64-6oJdxCqJd*8Fnn?@xOw!>aon6#t zf4;yo_KMbzSkv15hL9ynBk_2p%c1Uj=q+jVDV~yV#J~lA!Kgb&o%aF%8&OKqi2Ub2 z){`8e1>iG!1*9-XJdIM6652CboDVVXZt1E>$v*RHMm~KQ_D;5|ag+9gSP}{;L@9U= zvP?ap9<$t!(I)%;4N^aVXG0BTKDk1e(w6=dDF@O&MOyazOVs%au#b`Z9yr53$)1vG zEX)4!OZ_1Rn!ZZ;BCTjeS%x$tr^(^p5jnCBpM4Je*e{ppzw99;ms0m3u%c9bB-;4^ zRF<|$qb=b||L;dAE$zV%f%A>dgwz*;-h@DDrN&bZX**xQ`!b@g96J)ae~lXKCGnA% zX%Hm6C52^wrM9x9>^o~{r6kWJ{g_A0X)Rfwe?I|y@`)Bh>MW^BZzp=o|jF z$R`BNUdg_aE|g5pcD_Vu){*|9#DaLyrc)B6lt?To$CQKj!3&9vq>1be?|%ebCB13I z=wVA<(CgvYKz{xhT1FY5CVYiEDMfrD`A?dEg_b0x=*fI3S|W!j^Xw(ZF!q2Jl$_wd zPei{zg_KYaXoWbh*+A+g@}$i)Acr%Xk0C=p7JZ~t6LSMF`Uz_M7HS$nxvy{^fdssS zo&5)>!*X8%Cg~yh#(AR;Y5Iy^qfPdhExkm`pTXkO!*}Ys&<5f`-6bDLX;PPC1>5{k zU`lPH{?p6+9`gQuJbMZFge4`4(BDVP{{h@dYIwOHOs7;KNyPS~Uf%aB?!wcaZ& zqCib21eTDJD*GsD#Tp!~YcnR(P_g+YTYW|uD6fpzCPel2TpkJS()DPf4bLNl3vDJ1piV>RR z4CRWLkWL(JD0{?!(Ir|ZiI*mCqzCOe+u_(Psmgw`9HobLO!Ar7)5bA}7FX&7VaWQF zO+uoKF_%(ETSVC-JQ;!E2u_>H@r#t>oSmGdohIGr7t=$erzYb(qzPwiFTh#i!qG=k z^K)Tgzd+efaVKdZ`^T0kyVAO8eBxF1kdjLH^zvxoB#f7U#QMZmtI0C-+X$ankT#M! zjE_n0hw>olO}fy6kQP$6BqV9$WJFC$3^61>=$p~M=4io|HLW6y63bM&$ZU+c=qks40Fh8&gS^XI^n(n-mo%>5R|yif3DZ0ajqS(g3a zxWh4r^{B_3r;yV0$vfIg*>lbo*>BeU8L%XUUy8X5X-U84w{`y= zo=cdrHZhReOKiSEFEtw?rIwz~7w9=lYxwYct?nG+?0HhRFN%69O#=cibv@szNFL7#r10eQA)tiP)hQj ztuwmGx%Q{{5-R7XjQ9|mRn%h7DATfc^c_EgQu@PR0zT~&XHm4dlo#2$tW8;E^p5&Y zyUFKYLk6gu9G`v&&eF#v!wwa)cG3yp-xh=$aO-IUIr;edD5hu^kSbs0~8qx zrECy_^w=dP{L3-y3zQ?TIVYnx{ypSyb|>YKHi0vi_hH-Y;2>iP95G3mukrT?DMERP z8S>}wynli;G5emd?EeI5Vk;vhoM%%zXkAvLm(&8zIoVtKgfNOi%2E!=DN5t#DDxxngdPB`4JrGZxceWWInpLDYD@moB9lh!j}@iZ z8tK66PvDDuj1to8VBg7i!sV56L@a6HIESGhNIm!sz@~O`;m7tjm2P z@OuIJ{|4q4v~9Fy9J_p|`E%VL>HY<-ax5VR{8Glb0;oqnNMFhcPI5#($GG=&MZnP_ zOO#qE!KCZY1TQJCY?Jh)+|eeoU2=o-CFZgn>Ix;3|LAj4=2${fk#b7P(z_!+7$=cY z8R8@(d>?>|Kf_bbMu_+SAmr^!wE796r&7~2IU;;Y4WX>O0&+;MPLML}KO>r->3$dY z)J1aPCG_b_%*f^H*n5EeQup^E&y37U4Cw<>_di5Gq;2|4cZ#~yUh1kG&E@=seP+*z z9bpq2_L~~Ods2&ON`Rz^ghDFunKm9USIPu=`~|T70PrZ2g!mzNPu%EpN(@-u04~xB zNt#m%KSaOG$YVT%^71L_6~vX!lb{CHqLJ`xNmi z$_BBcY_L9k8EOb4Eo`6k`UD=eUzDRIkmWu@?hkY$q`yY5So0OuX9(?gK#>yq{e8eY zMs3axKGaooVcq|OyZ=)6@e9rtWGp-k9W(ldqKbd zU&QzR;@`#F?KXa+|9?sx|LOnB-|FAS{Wea~Na}R|YYM;NpFuf%{X4R*_ILHW^DmIa z-@@l_T!0Ic18=vO`sCnY704@EeKmCJv?A4DFdw=l@w!(5E^cKffEZ2=DY_x4woW7)R$e2LQU{^5H|+OpqF zzxwlEMz!zv|KuYOp}J){xSWtKlnGxc9{PDpX{Q{k-$r)|D`C;I>&$dQ$a)0;jb+}fxP`Ru}*KE z84-K+=W)USo{2yIrHAmBAD$=i=69Xne1^7pMg{t?EpS1f;(xOH7Xn}6whoVJmL)Cz z@Xt0A_pyD@>E8*R;8o)x%lyy(>N7zr;-r1~oHXV4_)o9JbMjPv+akRVkLB-U{~_qb z@2kXL{GvjBp|8ILjz1S|toozVk>~65WEy>m@ymYw><{{hKm4;rO#A-%FDGmdB$QvK z*WqhtZ)h;2PA$oc8>u_QU*^g*`KYCd1L>@#c`k_dWqsnMeVL}tXX6i}-$Vaa z^1=Vx=S;-Hdugee9>+;St zWnKF+{nwV?U4EGcZ(svnf^RjU6Po-=ef~Y6*Sy!#$45S=~ z)HiWn6l>vlqSjPD<$;T+G{sR>tUhhcc+#3Y%jT7(xef}CYdCC8-|o%T0<6));alR! z#L;|a72w{6RU5t5w}zAXYyE6eYqVHxhAn~5Vx@!+(J(-#G1JdcMBhj}a?&WRc{ z^`cY61!qv9)BFn%GjSBAiiE(S&}z@!$ATMp{)j_|^mmKlgmA_4r0CBZ>`RZ+F-nZc5f@F~reC4IIQJs6BJNssaPMQ*?Y$ zpHFKI(QbME8g$zMN5v7Sy0vr8GOgiQ$7A^jd*`V(oZy5;-ak8P6KR~CHXF;cFL53v zi|Gfo*W(4xWWye0AP1qN&;UeXtg=Vn?9C=9hB7=o&?$tTypv*&Y|$)&GZI>C?u}hwVY}B62P^9TUQCZu!sJ8koHnz*4fR=C z0BR)8{*|h)`!(88&v=u~bmW0=!eVKyRLd*sNn{ofX<&*zJxk-=aMI&B&N%P#O^m;- z%<{xJw#0LM?-xC&9?W;6?}U_4N!l%BfM^=BJ(@0_eX0j&Kodu+%`UHmJ;&*X%ub;` zsxQeX&MI8byxFVGRN$^xua2?59}Ujt(*@2`g%XL@#X;7P13~d-YhLS-&cCw1I7w63 zL>%NPdxP`T)F$<#+C#4+&nQHXgtez2N(MlkVa)x7G^(b$;*+&DsEm z3qC_%Kf@0VVk`mA#2JabL2v$=$SvUrK2_2~%qLOrD6EosNe)%??bbswYcJH*TxO zZl-Ue5RF7{3PXvqqDNY$bQ7Edj7|VfFTwSy(#4UxQz^JOgb|?Ey1jh(3 z&KT6B#Z8|PMkeSDu?yL=16kuD%~--+UAkNVi2Kqsl`1TCyzS+sXPTbDSZ_pbVDcIEBo z$70lOO#x?lmNVKBehaSY+GM_%w%j<6o5Udq^dC%?X`E)AgE%x{-W#yqaMFaor^f(K zPjogGBQ2dO4Ani*9NlGmf>=;=9(zot)l^NT16b47@rG94rLRn3I(gtDoNu%Mk)dlo zgu#X1g|=Ex6BwpeQy5F)HGNH2O`N7pZyfECCn}g38o+#j5(nr+$3 zTP;ic)8ol&{WtKG24e?3<3aQ1->~Y^r$w1(Pmz}90$mn^n+|8eN|y|?B;HHkoe6x9 zhC{OuSC|)Gh2)DfV^=dO<~IfqZ?z6aI8m2|s)K3Dh%d~cOkEty3H)F~NAyF5wBwo@ z*XuM^saB0A2#a=7IE-54@f_Y!4LUWQ$}%{~cG}dXdi5Tv=u!jvqPR|9kC?_8-W?o! zjPkQy1L+D(N*}fyG9s8oWgWtOYjj(UK4w6yGp#jyn8K;ox_WKMxgnm5`3mr!ws5xe zJgid`nth%bFJ_7I+*>`}UNnvJIel#ie$8=|>bwUp)=3G)6E(kG8#Tyc^(lSfDX6Q{ zop26@>!1dy!!?NyF1i#xyr%KtHG>bYJNWR5AJpd@ShtH0uY36Ln!|_JeSCP$KvSx7z5ADu>^s`Q#gT&B7;Am4Y;-l0IR|Fp?gPsy*!mQG;tJQ2I{7SP39ObFx!na#`L}JXiNyAW3eWbUd zZ`T^aiPHDl!Zy+~Aa5RFLiNk4(v;Nn&DW#a5HnDam(tD?ccn);?9Cc(c(HCd%*^J^ zL9g!W3gr-t6w^t)MVLBRJGyr(MoHIOR@LT3GOhu8Oj&_76LX_A-svrmZas#@xs_a$ zJVgrk8WsNk&71XlF;HLXy&jML$^rY#k;82BnH@Ayivb4L7Q`8&z@^^DGVhvdGZ=y2 zM{BQeYvWktIr4&Qc{0?)GDaw;gfwgP(CJ=Vm>51<_D4RK(UiqZ&>uWrl_yb!&^unK zo%qJvvIj9>sQ7+^F3Ha~Py-d7z{^iKB1$Dm$mE;xD+mQA^)kTVTGJPIvQQC>ZsT`A za^O>+>U3%xO7!AeK*0`UkixOm8jsX^%XW;e4Z)}Ne7yy}+yhT#CvQD%2(WNK)H32^ zYCg+Cb$H#WP3K))lf9|#6o++l;8V+D=o{*)OCG}9!Hv+gYEt8Y@yDc2mE@lm75oZ)LOW`cSPk_P0f6i-2`qv;fdOjGB#jKM+WKD_0s;0&c zP)0s-NcE9SLhc-1@1W&a`igM>r{hOVI}nC_BWy`-LpG9wUI%e#dI1t9L>d#UIevm- zGM>TfACH853*QcrsI|_N7``&X;euZzY4A$i@y~j>LaWvm<A zOQ1U{<|8bp<*6zL2|!$uItZ6vjLc$E8iWE^+8z^qU|TWA4)l;44V z^k!Y*T0ul+y*efla#9T6th1;gd;!}Hd&s`C8{kxvhOg3^%`qd#JQkTATLRVIG@N@_{p>2>WAn+eXFxoJ_lipJc6LLMFuqQRWSKq({ zAAxRo3=HN=QXtlcc~l*GF+y*jM1&t2LXVnuQ9}f}@dmy=4d0sj(bv@v6i(kzKaQsQ zap{}-mip1_^;nz|AD6zPetzCnKcrK&l63}wJEbYTpI5oUz=a3}fIA34!)nMWV;hqi z{UcUT;6q@7DOG{kqZ|V6n8zS?!e&+k5VjEHp}VKYEIf-Qobe=nEF3qC=4257s8q7> z?1r@wEU}y#5&+z8Sj~5|B?6ej(<4GN_wi0LQ`~XQ;ha&jmcdK(Z?6Zo!&-;+fBF0W z(O>@lfAW{V|A&A1`~UDSfB!$#Tl%$rufOQG`eW!-zBan+&BFS>`p^H#U;S5q{D1tn z|445c^}1Lzz(YwR;UegAL&_N`2VEBP=124%x{rt)mlY@hB#59CMVym*%VW3K=u*V^ zNDx+ggxcL2R>NwIMr(%WbVX1KMd^Q9UHYo(LYs3#atY1lGG^iMawUt341`#3QbT=V zXBaR984xQJ{u>2M#2co1%AN+fS)12fdSUSdT3WuC@`!aXF!%vKZ7kLSDC$qDaus`{ zFjgR3KK`@|{?bqvYfo?GC1GAiFtZFCXbQwU57~gyFVo~ zs(CQz7#(Y`we*JG(q4?jq!WZ(jdL@d*QFQJ>D6$o)A`5qiFa7PA zTmxN>eLW1mg8wq?MlF&)3PheBrHmEL=y{Tu{H>wh$kov4^gf4wV-sPkU!k z!Z;NQfJ7|M^(uv7rq!;2LJpOnB>RkRE!7ySp)N@^W>eFphXie5oV+39d>k!+DEwtG zsiwyYr<0UJcy$H@Xamc5+k z{hiO=1wiue?`Rs2bx_Tx{Wa$CQl~}VNd;+FIF!(qfX(lGo}^n+snu1Iy|YYuJ{{~Z zK9C(xORdKO1yoUHSRs&cK8$d92t&6Bqh#TT0eVyd02WFK37%m@y+(mz|)L za(e*0HN;?Hv>OPzuAZwQZO+tnx~K*OYiioc z!rH#U8LhZl8zw-6g2Y+~29Dk@s3_W0l>s1*a?3U#`B);sgyuT}LT@;xVmb>|;vk6F zQ8+9EOfK-V_!@IKT?V5jrU#Q(Wo(t zDy^?@nA6oBItVFvbQBc25_^~fj^UdQaSxNLE7v&6U=JCF1zyWCX4OELndXRl8#)|1 z^#~Xccq(Y_7ET^X^DhK{wFYdrSL2{Tv#b;gmmGOb% zYXMnNFuz;JLBCf%kuI_zzHsB0WqogyeI${yjLqp)y?vv6TWwqVPqJOfYi)iY_{6@d z&I>xcgV>iebfvM-4Ho`4K~bMRC>$K?4|C}}c7mMdDtr25NuMkxFLI?_ z{b91OQ>pCy9QwbitI8|#)afnS6N-i4KHElF`idfjdlkA)cLPxVth{dEDrH6O3yJa! zZ>-IT_?d)D9t&OwQCh#3RzN%}lbcHwm*ug@p%)DiFC^4^?tOA=9Vx*{)gAAq^kO8W z)XJOIle__JZ7eAw_`*K&BbuUwX`YSH*XC*>#3rR6X;J;=cw~l?s;>0XbC*NZ5Y0L` zH4wTA!QcWg+%&NdMDnrvRFw*G!Dv$)?tD%Wy2`T z1RJQ2$8#s=XIfJ*3b+@H6jN6^oNnlyUYo{nMOp6fU^C<+hEvSV)CJj<@2UXO%Y8Y?u?;R3Iz*lEyH17yony7I>KKPoqHJf5LOsrD8=Z(S%%tC zI9%|cx$2HlXvPV-+`b4jxDf=y6T}vvu~(w$WT+T%EVv&o_%gz$59_O#r3ArQY7hQ` z*J5;DK9{B)Pcp~qbFt@?dc-Qki4m0sbzWEz#24143^HFt8allPOaQ>0r4R~&iIgfz zh#^4tq(Z%GFc3ol!3u8AG%AR&po#+BL{S2~5GEaT##W(kgDPvNu`>{9okO)IdslCb zT8y6ws%pZ4u#enAiBJg0rV?H#{F>lnN9stpf$Y_OrK_?5eIE{bD4((^NwqeqWcmX_^=G=>rd5{cZ?s5cW_Fjmup2L zCbE`RmjKjqP5oj7w*|P#a;vl`#~Ci-O>p(OlYn7f;b-bA@M=+s?$`|an;yUsWLd7S z2tx;#Xw#!hs+zz}yV$)WaYQ*NthRX+O9I$3!UC9ABV6)YBlBW}NhsRlhEJM;np8Rh zVFVMw0N2tYYO_zFn++mE4N^TaZ1j=VQLJ`J*9+1j%s*NcbOd+A3eGI3GcNQ)(nF*d zK{emIg)B91?SAHmx1{B--OsjQ^|X9>Z$$K0v?*55^w+F-u390O6M?#U!tL*7i1pg~ zR&Ugpifyy=#})#E=okj^MsLP&i1-ixh{LP8;3fEm{($9(0n>S(Nx14#sz)ECc;H!- zVgL1K0;#g_wPxBn+$;#|IlzVpBX&KjYjX=NPfgFfTe6V${EalIgt#oG4qADnyVz8| zo)$o~`frq9yiuNMQQnx_+Ti>`YjgqUe=M z>lGf$XJoR9o6Hj}F7wn-muy5Wx5`6hV@qY=s%`bTY)DuS2y2;ZMi?X}S_~8ArF=u6 zm-i6n&P}i{`LE3&!ph1<%HnNSPn-fxrnJ*Dp^L5 zWu-%Ea-C)?SWtZ=gbvADjkY4S(k;K1FIw|2aYZpCwEE0f;fM!o_^fnSw6LL-Q&Sop zPz@!u_E>4v-iGc3oBYKpW?5AzJXaLdVY$|vs)zIg??wM{B}&j+U;7pI`tUyUe7d_z zH!=OC9i7eLkznN4Z0mX*Q3i&NF%$Rf5vxujmdSRxca2x>TjjNkr@UrLnVZZ`@!%%C zQz#%U_P7~mqMROAmgDtk0eenM#BeP34Ox;f$PX=d7Vi*X>f}~eEA_2;!^JU!;Uz3E za#Nmq5s?|WrOV3YYPlUuk}50qf#etp6cxqYTBf-5ubli19jE?`mx{${u?owrFH%*c zr)ot^V>VC8EoU;e$}x$5l)0Ommk z%SE_Ym#gd)!y>ST_?@^{2>^I9z3jG{UhlnDW{nD>jWt><+gasNfYi3>t#JkZ#XeE3xEkn-B53nA7Fv^HkaxrRZZLcVK+=9b1Qav4P6=}Yb)KKLB!PK=( zRVdz_c_YG^a6CsTZY6CsQ?JE@`JFAiqp%b}%D{KjIDn^tSJ5V|=DQ0XV?x9^=Ch}= z_2-zAxUJ^%JW&oowKuY{%bWV~tq+oI$QIjt-r@GX*zRKz3VmcAS{Qi4#R- zU|qO@)>rG#Yfs<$oUy~V3Sghkunr$tcyU}_=2jZva&QThJ3rK&xfTW|;ZKWA64<|i zl@BgFTXon%+nU~pvXD^7(M;}yeM?TBXWxi@B{B~?u~k|6mNI|u<`{EAS>RWd|LzjW z(d%bTtnhtHgk?D``yF!mT!_E3_&db-jXK{#k|i4JWxjn1ad1F=ioj z!Ue%L!UNdmg3vzq*EF%68h?Co9*JJc-U>lPJDjJc%HN;e~0MIS$LuWQ7|fVDmg&O!Ty^>-Vgq`kb64i~WY>*1QClgv=CKZbpihDGRn# zTCqp*350rN4IyX3`4f?J5wH5T`Y^asNkrq|whc=Jn^@x%%NoF4g};$RPq69!wB>}Edj9+d^C7977)aiAYWPjz80_)ZzbJe+miK_1xs|;t-oYC zB0E@$W~hxmoQk9HQNIH}rywBe$dzIUpokgDy;#HE2p%JMtuEUXKFW8t2_)Xp9(-tl z*(SC*(3y9m^09x+9;|u0!O3N;BH|toYij2nb{0*uTN3r5bk@x+zvgYid=L|}Bd`US0vFp?E@ z4?zwMA7kSW%X6Z4j_(D&^z0bVN#dR_Jz(Fc-1nsIhQl-Z&{%dRYKZaTPF?FuK8zc+ z=6Jc6lf+W<^msY`=dY;HVq@qVe+X+jZa~_4Y*QN(SYONkt_IQzyt|A&tZ&xW^1rLT zwm%hb2?|rMS6y}K6^kxvi}F~-#vA}H8DYKkoPl<^Spv)Ll1gutK{n|uJcC~ar!*FL zoWlMVd(GycB`oc70`XRx+1{L<)*)!vcrDkZGYBQV6US#|%i`w(ST4!wYIodc$5O2p z-ew+is;Wz4D+%`!XKKAZ_XV%>#|X6mYjyJ78ib>o2#?q5!d~v;<)ev^61ImCQe;58 z7*uZ{y!#rlng;9*8Qoo}rnbpejMk&pqu5sC!Y0e+vH^r5xj}^$@%kx-bH3;_;k#?k z!ncg7eM5EpW;Hd#&Q0uhLxlC&wpxqTEz`^K8NSDwLEt==v9>oLihlAnA-*ES*Msg(~3%}b+9Q|-A2Sk z47f*VSF?n$H=?*05wYHdVT9#fda+Xg#lcMx;^D$6jUy|AhTn*n55CdL3&RDYB_g{^ zM8vOeke#q>?1UOL9!VpqfnwheMy*${v3S=PQ&*&gk$rW_m+y3Y2Zv&G7FUd3_aJ%1Jm0b$ z>uYsneeS^)R1#(Jc=>z-_fjjN(0qUohbfGYGJ6jW~Q z-EU^Uv)}KqD_BTfy;kzgvtDQ~j_PZ5c-#<8FzBZ*Fb0hmzH@b9hAtv2xdpw)Q( z9J*@qR_Hs_rIa@X@62NNT4j$Gd<`7t0Q-Qji;qD{feGw_FbY^_=4yuQ0d}6lC~^|= zW`pOlL2mBH0w;A!QC9xjN|InB#jacWGx*IQlrzp=t&0$HI5%8+ek(SKUrwJR~=w31s+)Wv$f?*3Rq@6hsE zbJ`{Ybq6L;z#N0`qjOXwcR>tJFC-+@(}($)cOmBW7Vw5=#1U1j?Jqloer9{W_(kgf zWADua>!|96|1&d}1}aEo2T?99r3JdA8?>cM(zIy-5v*p5puO^^E8we`WlEjbB`8KY2P#waRAiEm4n< zPO*JlTB;NA$yQ^{w8b^-@J&x!tnbV`W6=&_gHE$fJ!!Xe%N=GdrmL0HOpfv_^>i}p zg%A_D7upTo4>s*E-8h*sFymJ4b-67se&*@C!`ze%Jrzf_Ca-1rqtB#FH>TyiitgU) zcbxRqr;$h5?K=TGy$woIqx|_2Mg+RG)#?p0)_kB=;?-;0W#^RtG-W7VY?Y4PN3^M7GKP0sToQe8;7!C6$^{s4$J+x#ac+HUh-&ZP~{{!taIeDIM(mD|Y( zIbZ9qDK^DNcOmH|nEee59q3Ue+jXszsrB^Tlvk~vrY9;{!XZN@y);AyPt;1XSg%=L zvrdn%rSNrZZ=sR3K{l}|is_dm8%$(Y%AXcFO0PE%D<)KU1BYR)>-3PO!>VUh2vs6H-1SS8+!p4Tn5e5lP9D zDP&MUd72E-DNklLOnPN(_Sqt1(DC|Wmc9$U`5t$A?2%@)!^$4Up;kV4ej;hC-uCw> zAeeL?*x@TVwuMdqu%g$aZ|v%*|j{!>*iWwp)pr=?ClL&KkN}`oKsylNoHWPzz=4 z7Inmwy#ti#hb#xlR> zXBm4bCBaSfh$ICnBc~=s^tD7cf!up*y;O`mBnfpobv3QCyq+Ox+=pl$v8fW7r7ouG zk+exaYlGGmM~98Q)A1<_r%m%`a&&Q!@QzTrf1$j#TA+hTfISyurkY z%#_eT7f3SmBosxtL4G;KQonj@m01uSDQmbwi}7TIy)H(QwQM<{A&n|;rksihu{MhC zcfyndb8b{mmg!Z#%=J=+*;3fT3xA^q1`)xE-a(W0*<{rXv1Qb*_hD8>k|AqH=})vL z4jnIx(wFH9r#`)vr^g}}9)>Jeqdq&H=PEm5DcOFRVfBls&(Z1g&EzGqlntF`ndjD} z0AZ0%IzL^<8dXWYml~ds9)8+huGzq$mtdt&)*TqmYjp;1)LoxtEp1CTpXv*(kwfNU zwDP+$-8(gN^E!Pb&yPsPGzH?XW;cC%6T7pdNK1`jUluXbi$XeCel2}2{O9ab^XK|) z&sWO3zEj;XV}WIkXEqCUPNqe#=aHkukZ9<2>XKnwFzHL^{b9|?q|q(7+N8(NJxSXr zNz2S<>t>Y%(;w1HyCmQJ`EL;iW2GxM#=X+s>JEd8c_-GhJylNiY2~dy?p{n7gSpOa8N+GNt?>rud!I zDF3K?W!~BL2h3p7Tx4|~>PCZ}kH|MYZR#0hSFc4_t>@pRsHat%oD;4tzZ`j^!u|!j z3sa^HY(3gwRJb5ptVB!F$TE>Bo3FDojv{x~jtS1pc{zE^{Z8}eIf;V;lyfbD^`GyQ z^<~41PK=zG5lW!{Y`TUN9ipRt%v_pTeav*z%>yVmGx0LJpzDVkc~JbMxXDrG8zzxK zatw6$tod}YQp;tTqTafe?GH*g6kxna8Kr&v&+k#{CC2V1@#dVdAv-=7pjubL=zc^$m^FMF4fjiS)Eq~19^7(10XTYqS0#fEtrd3&~*J+r*4511{iT(hBURpl~zQNCN+KiOuK zah)+|wt0bSpsdPkxLM7-HEPt$MQwPxMMi%C`ATUtaWplwnjVHWH)eG9WUV6(%{61c zL@W2hn29uSPpk>oQAxctrKEe(CiAi{8>4o^iy7I#OLSRxzJD8q*j2BuVrvEU6zW;H zR7Nc>^@3~*J4tj zv9vbP9vHtii1eA4N|&m}`bP zc+8v=K<1o)M72aPoJuoaMkClPq3QCSXSR?<_;mO);qYQBbIuE{%=t;2%L+5%S+jIO zoUJA@jyqglku!SG12867-A*u zzMRX??^27D>9%XZ0^Z%~k}Xc@dUn=NDbaJ66e!v&y+VOUCW{I;6GMHQY^{^&cu|jM zM!&>VY4le5(M_4ubc9s9vgXaK`lq0feo;^(c_rG8u#>KTu7xqzJJEA3NV^2im_*-4 zRH6$<7+ic*AnKr#@g_g~iUmoR&HJ(?*snYE6H1d3y%U~ervBr6oz@M$rdkqe&X;e@ zp08P6&6Rbtv3faj!th$`?G_`NM0q;wmy%K-^WY-u*lXF74vA>z;*UKzL>)u-G!FJySp zMlqMdt)uhv$>tLKK-RX=p_lj9c89LC^V!w?x--(z!ibH%BeEw2$NJ7Cu?*4@?UE;2 zN0UzH>dG2kDQV-WI^$PWmM>pZy<7{1?!2_LlYH4oB>Ej08>6Io#?mfXgjSig(a%@( zGur-S12Z}D&>NeP&gP^%-e6iLv4Ry5GIJ}*W;7n1o~Z3SLW_=`#>1?#4T0ER+0-3n zEN?ipIpHFK^ko*rYik=*tzB#)>q;+@4w!FVxf+$&wN?Re?b@Z)YuU)RytZQf8vRmG zmt)^;?Z(PAve-Ivy}G)*me+(5U{-HvRcn2xWQvReOySMit+TUHId&%7^c41jIBlq2 z?JeB{qmP$X&t_QG%<5?7{<3C)9)~sOwY6!JvO(b9DnZt6%(*GCw4|ckm>=miX=1`> zZS|(53AS&w*xg3id&y03JfLS)&UN`T0qf^0X2BH3{j9(|s5h1HMd6EXR48VgO*Oh> z{j8Z9r@E1ak-9v{qm=YA1e7i8)?74>m}$>|o!(j9&?Oo`s+rms{{eSqU~b0X_H9p& zgP^?`i)G`IJTvw>jwtUz`*pH;hib!wpX)a-XcMlquGRjcm0+@MxME+~j`EO5N9+ee z4N@a(20FGfh%ql_h<93im1xhA5xxj8BX*tPR8}uN)`<4>b(kgSTb6ZG6GQ;%8`zOH0s zcob0RldXt+T|W4xs-^{K*5j->`(h8|wCVe*Kn zbQP&(nS;TCwum}ZDtVTW=*O#H^HA5x{yRpAx|?FYO;91lHDIKj`%jzvHl@ovVlK^I ze|xFtDD8Q*>?>pouDDqz%X~Y{m6*@42IK?tuRJo@>zLh@$QA^x=x2I-neBR*gwhC5 z59-IPC-7u;tR7K7_Y`WUq|-TpHzvGxl))`GCOQ~d0HqsTNe!)5o7T_6!<8vg#>aFC zk!+Cy5penDf}}S`g18P!gxCj4vOW)%TCuN5vLa-;=yS4SB!2XCk1g6VP)s~G%uY@g=l_3(hp1rUyR?U6NteKhIWt^#>uDH{WFl1~lrKgq&&a6#i zVvnLAohL^8T6EDLt@noLPC-B|lDux{lvz_dVG-jfoX^;+cqQ` z=Nw5OB0}_Dv%Sh{QQSk#VZ0u@ht`o|+-0YMC#6rFbYxn*NjP-MXEj^RS)s!bCV(0? z*)lz6dIwz8)X2&~kxgbU*{)M7n`XF{4HR+an9BdRt<6*3LF8`ACR);O zawc$&ZWFUN%2a=(UFuqKz%Qq{2(%8->fWT!ubVAKoze{RzK5{%NMpjJ^aPeGFnf{e zX4KOZ-`v`h+CmS6(`F|ArCh*Eahrm0H@j6}g(gbA`pO`TRS*;h6^9Hc3KE+!f(qoqv zrKu9-T80_Ai9-^kS=N&gVyGMI>G2b3A!R{?Olj~6N%TtUI-V!PQZilDvvwlU&09wK zWQFMySdlTlWsqfFPU%jqM4D04C8;1;j9!e$BXXkHju`=IQDlUdZG^eeDJ$3<%=dug z?fDi8#sZyu)2*7;9h$Sq3*E>S*RmR`_9Syw?7RN;gq}*nLF&lNff>d)1RuoJ$Dl$y4KNGtWb& z^_r#<;?#JRc&=`*Ppy=&)CyfH%^=B~D`iTmJt7n9kK)b2rs>noQQR_)W=vJigq@LqK}xiIB+3hZ_vy8XG`0<>m$EMXGb(0g%+WO6m=IOY+ofAHRX=oI zexMeJ7tJj0(cdiaAG>Y<)>le1mK7k%1~ZP*?bX&=2CcYcv|C8&72VldZcM?F8bX&x zqjUlpZ>6iHm9dGum$kM^XCp1^;iQpaeu^eW^bG1IK-d1bm+$D1CDL$i*Du|StV^D4 zZcR2&I<@S}wHY3f51g0LS)E2>rDrVkxdg@n+S$R}u-*8KQ4WYPapIRv@7{aZ?A%%YTM-bO~8agm5$1l{vZ^*8Q^8 z-RLn}VeZ9mMwGmFmh|c!|IGKT=Y3=5nkH)S6!Cql`GM!cGOyFzY@BiB**wV_5!f(R@NreGQ%V95Hja2?RpJE=9*S+HC=sq zn}avzp3KW=9d0#!9O(ghA;i`p-O74YSld0iWKsun za*P5qYrmzLN_Wx*O{Hy=`W(TQCEnz*ybhWy*B)MTB=_4A+bQ)^E#gI; z))Zf+-_gr+(eE8H>P5v~U+9KGd^4wG6%0|W^vI3Tv6B{=l*wB({X$c}zs`oc96g{N z>SPoxCOb~m4JPZxs5>L5kx8o>V5$sYnzuz@w0x!B+^_#BN3A{I%po5xl zM7B)XH;*_K(lyiWO!I=x z8fhClX^W*&oiJ(ok?9GCiU)#b?4q?LGruY>5^4EDp@c2=_WOEF&}WO7=|2YS_>K!s z)yd1KI$6XZc{P_Mfw~Z2E|Yy?k8&I>r}}=mUfR{x%rePVL_*#HclK8>`W9vC|?%Sm&CN_`PV=42VA z({3=6(UM}>vlKG67hox~wair{TDsD_7GrQG<(8_vv84%R^%O&9fwi=ju;YKZCMX@ld*2GKg3o?$-xX{woe?pYcQsfhIC1>d!6lTNtS_Nx~kB1znu zuFjb5LD8yiH#2KQ>@Y5~1BJKQ`Xv!>YW0|Vyly$A-5_hSi!f+y17ANdZ>yx2T5eKI zUx81+NM)6gt?WV!TOCoBdEqGCA%9T~f$GY%o|hRsU^>iFf9WbubVACya@{$heUOT8 zy`6>Eo8XNiSLy1D6TOf}+)SZ|Da$I8NhmYDttWvoTdBmRd=ImZ7N-3RhkSHQf5Giy9e_e+;Te@=(S zkP@U_ATH7lOly_}snW{GW0PK?QbBOWf`q!{$g|UGEu_tdwmjA zXL7t5rkjqJ4U%z9W4#QJ^irJddik#?9HP0c*WY~90}npMz*k?_=v{V_CetZo@<59e z(kTYIGmid4o! zaeaj!V>gHO(sT9xMr)lhDA(UOUBHegdg&PO*be) z?3PgH+3U=$&~9fRD{G~WOxx<+R8xn>R~rpYG|V_4k6M1(b(kdr0&*%*RMY zpS2zk%h;Hg3dmLPa=aaEnlBw{36#>ICz_^@pJMiv=mi#1a?G5vEb7ozg%%p~?vB=0 z8|krBM(=XiZedG1doo&@WYLGoE9%W;N`Gt-BYm!;Zk0Qs%@-|Me1P7|$kc1$)YZN`b! z3~F)X?Engf@-`pPSd zFX<~@@`Y;;TJrc~E4BM;uek>MC#a@+ar=aJ>tFlf1+OJ62{&tJ!uGEvHU4?n?IGuF z)$#cDI4phX^m8RVej`g9{yw~XT(KbM=RQBKSa1X8a_*bQ0_Jk=oA1i`0WXXz7WDa1 zMa2hzcK<8F2Qimp9COisC;jC~t<7p;b@{rrt5(T&e*gSLeU6%MdCPus_o?dS_^E12 z_YrDJ{0ONZnngoo{7lANJNfBwCNctSNY+j&nbjoMNBRRkDPu>9iGB`?#{XjC!sK4( zEZG0vpU%7ek;%tAc+98gUh&Ygv$sES)U4Xn1tk+FvhxMk9P4H8(=<3rUvI+fL^ugH zD#n&--2(Z``!;)AYL8|1xY8c0?Qw%WPAV}Umcze3!@oY_Umx+WkNDR|{OcqB^>OtA zw4l@ebJTqc-Bn`HK9QT>6hzV;zMd#uT%Jk3(;PFra-X_JHm}OKHmY=4Kbl4_9N+QW z!po6*`)*_{Eo%#}%#A;G!`UmogSojuhb6uwOrxvM>U!4S1<6U{_;u1xo*G|a4lIE~ zZx{2eOsFy{_5bRALykYWA^aMz@|WD?FL@c^-2^3p$PBU$wc0;nGFMDSvy))0BUGU( zRG+ffpj)9;bk=C_&RmRWA%m$fh12O7Q> zJIT-NOGLbIttSNiM`hk!8I`(fqAaKuT{5`SOQhyapR;*<<}7Q5J#(|Voo?ophMY{& zi%jj2LO;nG=!3~F;$}XrOLiSfIu^oWB{M2qDmyIYtXGN5i5z}-#;+HS|HTc9Rvoh& z_2ceK&W_DpGIZCeOFG^;i+c5%C9`MWMIAP1>#<=umd>92H+y|p=@F+aDaFkGPAuhn zO|%1lDpl%p)b)3l8;fB%4)56U=87Hq_vTq#KSVqaaU2BuJ8@8{$G*Q~$63bNjyHGs zHcFjE7(uj6ueImcyTqRBgZU1obdqc7K^eWP>h|wfz@zF8$oY+wnF#l^rp3N(uQ~Cr zhiRYWr|*a3h}_qR+?P4-Igca1y5+kXFH+U>8;Q@3(XfD`a^A5&=X+}lReaH|#dR<; zv#9v8;&H|Af?sX2+&p1sW0aaVD{J2%3uI)go1WvOZ3x@RCwf?GLXRrZzS+DleHu44 zdyVsNL`VMEP@`T~ya!h)8lU@S7peOWEYf!U`tN`5&z7TiEsoDFDn1-$3Ci93l$e!=j9e#P$ZxO+Vio}}Szxh9`|dpXK47>@7f$GeYH zy?c*S{V)i_p!ON3;!p~8@FO^Fzj5k%7`Oj8RRUFzf<734AsB(;1F(lJa0~nr)PaNt zUxCM9@AN&K#p0Z zc6WEKnRa(yj#-s<_du?hb~l(~R-@fLjM?tQHC?BrM!OrrERIl2?~r?-rkGizN*vti z>%*iPSICmOTKpNabhmM;$fOYt$gsyW=n^aed_WyrCs zsuTN;bVuW1C9>r})nV4F^HQ7XG>LieC$e${_2PtGE;|sXihIq}6+w4m=erei-;c;{ z(W8~IN*W&G zC}GQ(sjfiSep-Xi#J|t~%5jK%_TBr>roTX(l6K#1_$YqmUY;)CH<(`EuODCW{OJ4> zKjP-Y9Jds3lW%hTAjgL|N)PQxj*@`qIev)a?>X+p@t+)}TeS;i zO6r}xIqu8xP>%a?oWYTUxRx05vX5eLrH^&BOvTR2Mo-^o$({{fDY#z#3y{y)u8;(n2%r0I2Q z-~VCb?hcL;w}hbB-iHy}@1bPo++yWy|H;LiU;k=uNei*dJlF7J(K2TE_OF%F5 z!vKtcVxo)bUR4SMFbscVF*T`m>zx!^g=%jgKRo3 zhB%Z!slccs1(HvF90y?-MnE1Z|ek>BU$h?H z?k+lpW7?SgqoI`OX z`2;1$VFpzo`7_9|gmCJPH~8U%_#4!v?-opoEsc`rzu{c?n1D5)V&LE;?Y=*Ownn>YtK3Weev#!gThxED|xvu=Ai z9{~M4IgUW_CfvaQ==(e|8)p^g`aU@hL!mgeQtp!o3+iAPe7B`16Fx|seH;g12;!#@ zw!nQ3bM)`?f2s_P5T?XgdMfdPUxr3FmpFrEXy{|+K2x>013&HI=h-KA&<`U}T9x{6GqP_XC^{3M7&=13)y0{NZoMQ=;LKW0O3VNXr`e6VDVF-p{1k^UdfD$N$I!Hk;^g%xi z!Uz;^#~su`FZ96x48jnoZqf~2Lmt!>J03m6jIO!{V)W>P<$qFKri&eAdEoqC-4Jxkb++5gMJu*K^Ou_<1oh& zP@lvf#Gw>Y&<6uB4C*ZGAr2)_1-;M@gD?Wcz1Tw)^g=%jL;P&~Kq*u~9i*Ta`k)^M zU=T(?eF{HN0;Ny|b&!Hy=!1S3fI%37VHg2*4(Wh6lt3v|K??ey9|m9$hC!W+dx%2` zltLY(pcnd}9|mCvhG7KMdH91A^g!vGAz5Ddczs88b-;!px97=RJE{*0lNV-?gv z3VNXr`e6WuU>HWA_dg%tEc9}K_{48sVh3vmx6 zPz80+3;i$%!!QEsv$%selt3xeK`->d01Uz~sL$aJs-PG8VGxEveV%Y24y8~9b&!Hy z=z{?mf)Oabi1?rss-O;1&(FuAHp!a3;T8!sVPtcX}ARLhG*dS5bG*Z z6QKsqf_}IYegZGS+pzbxA~h9OLmF;`$KVgJ$9D1*Rzn9|4tK%N;1BRV?A=|YCPNu) zfbDQCdf#Nd= z7v{qz=z{a$3U~lsfrHK@UC;z)Kp)%*kHJf@+b1YrFb~$j$Kg|O4cr0Gz`JnBCvgKc zuo=#T%i%Wo0sI2qfN^IPsY78NtcFI|4j03X@Ll*R`~`OHr7XgHSPKa_11^JG;X!x? z{s8K1$`~94$3qjG1y{kh;92-HxSuLg`@=jq1r!1v%a_%|GMPLVnW)<7ei315I) z;Q{zDJO_V*_uzFM@L(_X>;QR5%^3fP3KQ@OL=q)5HZQK`&en--X|R z^BL|R7Q?B~1J}d-Fbun&PuYVCXo63`b#Nd26#fLeTtK;j`LGU>a0%Q7kHa5fmkUWJ zEQV8HJ6r;{!^7|@{2L~ImgfMc!3A(L48m{VJ=o`SMQR4DgjzTgu7Eq?Y4|hj{&~_2 zE1?O_hA+YW@HD&$MHeBnPzqb%O87SX4E_QixR~b*E1>~C30K1aJO!`AxIUf>ltUwY z8omtQg%{vG*#D9uH4E0jX1D;p0>g0FrQ{cEgMN4fM&N+Uiqs-#f(zhwcn02uiI*e8 zunoQpKY_R4BUkW@AO%;!gYXLMdL?xyoCxQ^z3>A36ArklNX>x_&;^&kH{i$cD(rGK z&kV|-89oJHg~#DF*yS4J7Al|#&W10+{qQ2Z0~4<;Qq`~>E`e{t6YyvFz!!?t;ZP1A zgY9r7d=rM?@37}})ag(IDYyu}4o|`#VB8mp0~SFYoDTi)1iS&`t|y;i5u5_ua0%QF zkH8D?4(#rY2+mi? zM<|CzI2&$+N8tCc*A0{r*aT<8SKtx&J$&%1+&`QEX}A>bhv#6o8;jHuXohp(CU_WL zhuv6tw{Wkp5jx>oxEEf658XNpi!Y%MHyaeyTM{lPNg$-~zTn)Fw zqwqZZ13vh5oNFQ(zl>9&Uj9;VJkd?0`eQQKXhb z6ZF94a2q@dzk#=4j{)L_W8ehX3}-_>+yg&@zre2F~bgR zgX5qUPKQ3Y9Ug(_;cu|pUC28e1FK;(d>XEU``{Pw1{B>*ys!{zU@M#hSHnHhKJ#o@K@OLe&ijFg=%Pp zPr+62br^&f;7!=$JM;x%Ei}R>;8OTHJOaOhzrt=0P!?e(90#?~4Oha~;8A!5-i5s$ zBrjn(oB|zi0elheho|5*P~WBO!hSFj=E5>K0XD-Y;6nH!+zR)>Bk*f@3-)}7XA3i6 zF|39S&2M)@5pIX?!*lRg*maQpB20v1;5cZ44)`400QbYw@D}XBg9ozvA!B64$uqOZW@8KO_#A4a?zU z&<&r4>)`9~J$M1$hH;P4=YVSXBwPl!!nfgZcotrUw?I8k9>Ek?2q!}V&W4NNHh2>L z0(<-jS%ezsfKS8Ka5FpzPs1zl9_;;N$^%S=1yBwrz{j8!PKWd1GWZgF4eo_U;At3! zw_vv?iqwZ;8k9mcG{H7F53Yb);Zb-7UWK<{mnUh1APyx^2AiN6y5S<|hdW^qhTs)= z8+LyRS%wl=2$ir2w!j&1G4#Xz@GQIxZ^An;{wK&Q912t6Xjl##p#fT<2hM}*;BI&v zo`KikeJCCxewYF!umsk^sn8B*!WD1}+za1_r{GucI{Y1CKSh?{2v`JF&;XrqK3oDf z!=3OWcm@6fyZnrNgCk%etb-=#f(zhkxCQQmC*im7Hhl2s^z-0oSP3UX2YeQ8g73gn z@LO=6CT(y8EP&%-6C_|eTnJaejqqJ~7JdisLGd$;^&5#XH^wyg<7d9 z)p6>0UXia>Yt&j*#S7_ms#?{k^}OEQs5bFMJ)XV`k1O!b-ZwFP>s9_Oz^sA zv)ZCsc2*;Rkx|HsoT}p)g9^^YCwHc-Kp+UcdKuyd(^$^KJ{&Nzxs}P zKs~6ws~%E=>U-+@>Idp!^@w^@{ZKuo9#=n7KUPnuC)HExCu&IjRQ*i-Ts^IxQO~Mh zs9&n*)UVX@>IL;{^`iQX8dfi<->R3@E9zDCn);o3UHxADLH$wvN&Q*9q25#@>M!cA z>Tl}r>MivT^-uM-dPlvh-c$cl|5op-9Xx)=aUIWzIlDOHoFZpeXE$fO^8sgfXAkFt z&Yn)O^C4$1XK!a8XJ2POXMg7a=RoHm=flpy&PSY&I)^xM=TK*YGtoKBndBVqOm?O? zM>t11M>$iSY0h+KhEw9qbY?lTojJ~2=V<2`XPz_PS>PP&EOZt*i=8D-sZ-`Gb;_M( z&T^;1S>dd7DxKq;2XeX&T!6j zKH+@QIm_vF&UQZKoa3D9oacPn`HXYEbAfZA^I7L}&gY$roQs`4=Mv{q=Q8JV=L+Xa z=PKuF=Nji)=L^nt&KI5Qoi924&X=99I5#+7b#8QSa&C5Rac*^PbH3)>?tI<3!}*3Y z;C$1$)49vJ+xeDrk8`hcpYv_!e&;*R1I~lacb$ivLFaqU_njX&4?B-Ik2*he9&;Xd ze&qbvdBSh9)_cR%3n?(X4!(B0E5c0c6qM3=kD(w z;2!86mKbMrEa;q%w6tQxGUV1Zl!yid%U~KUG1)M z*Sb~i3GO<#+O2WdyBpk%?k4v{_aygZ_Z0V3_hW9YTj$oh4Q`{`-SgZ} zyPt8-cQ0@+bU*8U&i%Z5k$bV*=U(Do>R#qv?q10aet?Ox+v>wdw#&i$f$z56A% z-~F=t754`BtL}~NP43O^E$*%EZSL3H+ug6bcevkh2i$MEce;1Ece~$m?{V*S?{mNH z-tT_LeZYOt{jU3vJLrDT{l5DH_hI)D_fhwU?qlxb?vLCbyHB`Jx=*=3afjTWx<7M& z?mq24<38*D!u_TDock;HdG`hP*Y1n%Z`@(`CHJ@P%kC@gtL|&=@7&kj-@AWs|LFe7 z{j>Xq`=&eM{>A;P`#1OR?py9Z+<&@nyYIN~y6?IFa{ukV@9v=LcRbhgyqLF(H_j{a zcJ+4i#(N*|cK7!1KIrY~6?-4@_VV`j_VM=h_Vf1l4)6~24)Q+i9qfI?`>1z_7xxbJ zCU_IQ!@Nn};of9#ig$!}q<54z)tlx`_hxt{-b`)<*oMCcx$~X?*wn1SMAk!>%9%$MsJgM zqIZ&avUiGis`oLk)~oaCy#}w*Yw{9av$xsX;+>%0F7+<+F88kRuJo?*uJ*3+uJyj)UFUt#yWabf*YADV`-*pi_f_vk?6si-tFGky*s>bcmv)yy*s_Tyt}<`dG~ntdiQzX_U`w-<2~R#=zZ6F$Q$&&=Y8M% zf%mZYi1(=XL+>%~aqmaokG&_nC%vbFAC_mcNp?`7{5?^W+L?|0to-tWCXcz^W%YhKn2`!YBZF;YMt?We)oY$fbef_eU2%}jUGwVEjt-nGOHmpR0h#$N?u4jXD$Vk*R zXUxzJ986Rbx(z#$Jy?sXmGZWx+RRzNEZ5aCwkOsa&4I?THdvMrMd;n=A2Euy($>GW z%(@GjRyU%YRCGk6))IX%Sx2?G5w1cTOf@RNMfqY*#Q7E#?5SUkI{gm+mU5h!7=lJN z(x6f8>O{xpM3e=2hjLN$>U5T)eW#rdGUf+Zs}mY!k$+FMs2f|FI32Y_1d9UcY-nOr z&c^Nr^x}k#TRQk;Q=}mp4@FC1C>T*q+sy}2dm^pvV-I<%)M`L-1JY(Ebk&C=(B@i0 zd|uqE(B~BjSrQ`ZfM%CK9EPNUrWsu2ww`9`ANx~j7y zY}3(#-le?!ud&AYX|N?F9WGS0zD2fB1*6K?O0mze&>A}f$<=}wS?m!NR9dgq%GQHH z@Tm)5=vJduB@kAwO}4g@LLwqk8|gqQoJbd_ZYgN9lfYZrt%IDvv!Mk8u0mZ>Sw~|{ zGSaXD)x2SgfY9ap3f64;rX_rNuqbvzlEPt08P5;InCgeVtV_NPFN#33$*+|#!{u1a zs;P~)=DJL#{HK)@Kr$r-7k$l@%W}-o?j@45UK*avQxTnCdC^(3D3|(cX5j$%5Kh== zBO1;VeCH_AJnSA-Cy{p&Ft0#)I^U$=qX;=6;v({9*Qc7u*Qh{^O{Ax6JuD)wwS60n zX_7%Se-Wl6Cc?C~GF>HK!IBCw$~qzCPrL6mCxkbq(J`D(occDdz@qT)im%O-n^mD4yd{lUF}l zLTa|uw~XR{LrbEw9fgbekpw=jRUn_Oaamd`VV@U{C1Z^`r!w82&E7=dhH|`Brll<9 z3I$CoLFxK28$hm9Qm6A#I4kw$!Uk(?a-9dBzb?A;N2RC6hZd}_Xa}amjOv7h`iYMS zLr1o=Q2d5V?lmF|O2|^(mndLwayH*%;bfD)qlTE9cal>&bQ_>tqwBan70A9?eWRL8sY54|PriH0B z-(3i1m@x^Io?4!YpPrz@?88{m)l#`ua$i@F;-(%I-co`K*reCjREUroYhBE8y-MY4 zEbTFKog1rsc|elt4{aoWYnSnjCK_>);Rh4xOn;%zest9aAL-7dAj)b~U+6LK&<}0Y zMC9C#bPlEOf$Hztr3p0bnFxZ$%lUk$PEgP=Y>@9l6b&40Hw7Kh8R9{rRaTF@gCV7> zIucsle2(*+o2fRRg{!J>=`eQ^Fz_cn2r^)r=gdrn?8K27&xIUCrNq=j)qG}QX%C;L zGtDII}q;4)YeL-|x**gXHH#I-h!avr`pag14%(+$a%rtocwb8DXG zh1!BCo4g35YR|hNsaYs6(oO|#6VoW~p@i@;8vmJb>W3hvdKQQ@NY!qIPk)gnx2#IF zVJ4PLFxhJpR`$A98C#uo2hV<)YYD_ntd8U51z$VSQm7!stQ~g{eMaEISeY%W~ zUI&w7L*x55=>mT8@<4ZEvJX*TW@C!7Wl$V;P$1M$#+tzR_NwmpkO4%SYF)Nzer>r{ zS}&b}wA?SlXcI%ofwl9;PXCFU%J$6sV=%%>K5rTFUTJivGlE@41=*M|AF{9_kV#0^ z)hMa;zy2ADVI55?W4P!$G(86?2ez9NOm6j-uFfXD&=Lr6qbSd;4c&(^jELS?Y;14h z>l%$K^|ztrAu<e0`BJoY6{%bmf%C~i#~6-6t&XC-i{M}SmNlleE9{`Qi?2y_@QIN^8QaX)kP7Cy zwj4c;3=9(8wK#06P3f8{GA(>;g&t<1G^CQL+R=&!9~|1Ua|ff|Nwz78Odr;!O&P_u zrcm-n^D1_=6i)Mn6)pSu1t`6}UV6N_aqG8HVWa=dmGKqjb|<1roRQDLninVuVjC%* zzC~ew1;rAt(ISaOA#ubiS`@`XcQ3-(DaM5p7cG7gSV7VAEenesE}{#nZ&5fsI}tSk zC?ICo6cjPBD=1#RWx*5|5-U6w5UGq!zBpkODN5G7uo#Jh2oYjxKHQ#}+4`Jf5bY{j zgv9OWA|x)NM94Rfe!AK=N`x{Nh5Z#0A@Le1LSj)sgv2URgtSGz2wCI8iHj5=?W>Ro zWh@Jdkhq8}kQs}@=^0&wB!FlU5}QIIr0oicP{y)giVKL4c#IaItWBN>iB*&c`Q`;h zNIQrSp$)X!VHpy$aNAPIU9=c!*Q3jkb`m8>8H?zLY^U4Po&GRxn4Wd7@X)(SLR?g)5S%fb;8=C|6O{OQgG~nx>$`|LD#m>Yu0p^Q)r5u5xOn zC}-gcs*sz=x+>CfM75Q9b(~XMW!@o2n1<^n<2JfVvY{95B1kf=qo@ifU=>~Ld0c2u6EPkQ6dTGO=T}2C?xE)>W#6^_Q`R38jT-!zoT*jiXze2($ zUL!?KED8vkSVfANw#XMUYg{;SkpiZD6%wzEWkKN*7mK$rB{8iV`E=yr2+i2O$ySb!_f}mrR?LYZDw0=h_6NFV`kt zymIYFk+P7(u&_l~=NE^tqp;{j+3z%zC_xMblqZiN`v|cNxyX~wuzjwO=G*S{Hu6L^ z97dGnM!AU;;E=;Ssfe=QX_5;|btt%e;SM>7lJT&UC{d4cv$K1P5d2Uu`SKs>Ag3A# zxd_(=5!R8FLfBn?-5`rP{KYcCnjvEzsuwcmp;{qh9$6=3Y)7vVvd$vvgIvqV(iCtK zQ5S@4cM?K@dLSD}R4tITjjjW-_E9xJz&20*bL@7K^eEX6_%9&&As2<@KI<$>GD5aH zN$98&pA9Nf-m}&Pq&?uEfUJjHjDA1Sa-Iz$Qp&^DVHwZbM@V?CWg+Z2IV?q80j)!qOTvR&6C!E&nQt1Sx3rg)=gfa4q1(svclq-4J2PSvvyH}8L*9#%8>OasgIDy ztmk}T4BO>MV%9P&hPgJ8G8k|Y5383?l?bjPpcB8|Dg&HHuC|o`7iAQKFHth!hI3%_~qD!|1pRi-35{ zFZ^N}RqVBSRDsV}M5ZjFkc)@>;+-|kDcE8hF4DePWMS5pp<+z2%qhom9c(?K?DLDV zc2&46YwK`f&KTxD9AgzO&RNp}KB5Y=_LNtmwP{3=*5-L-+L-1RYTv9tQu2zmaUWH# zvo?_hTU+OqpR8$t1QagY+G~E{*2Yn#+gL;u@2pL9`XUOr_L5)11I9T;T$_i>c*ZcY zkQ>|lQf?Q8n`NaqniDGJdG@%$ah|JDOZl9zvkAiLkmECvjRzpD&>S+pp;viLZy68e*LYZ*JZ0f0!A(6b0Vs69b$n}J|}vK zr|}}?KdO|^k^0(hzrkg;ctzCXIwVv0!=-#qUQMnYOVKY>%JC8^AQ|kGXoFx0 zj&@A%-N5_QG$Pv2H2#GR5gj0>fruxJ_2 z`7MYsj}k6x6V-+UtO}$uLcWZr{AMI*o+Dw#BHWN5C0iTj7i(jjU#7F>QEAF6&DwdmCfM`I#vT2qhGz)s(EMMttr(yrrPO&4T!qP=S=4T^8XW$-*;Rh3L-z3L0r zICXNHm7R$;-%rq7Hrhv-vjdkMyg4?jlTG!lz6ttO0?~36jG%_i|D7%R7Eo|xZcLv@ zhD!*Uiw*k9=Cx>Kkzh8qG1WH%rVTFxECj#&4jZLy6Q^vGjL7vk#HilG4Jv^r-$&8He&f1`OvoncKqmVHs zok>y3spCs_Sl9TcWb42R+XS*K*&5|Fqx!}MzPzcWbG9FzT+Hz=s#?%x){(I@m)5qc zjZUz)-g6W3PMFw!Ct!)!pc(?b198S8hCX;;vr;_lg`5SHn9~b!;32aS||gh zP+zZ1v~1quC$Ix$UdCW!3+g*X0fg>@aI=-mOa-Y=bq!-uTe-~CmSVov8qsEoM#xMF z6sffaId_t8Ztoytff_2ECjo=#5CSSzb3A18+YchQZI)!))CDYTGH99ulFk*%pVH|> zQ(0S9lmq$!O;WXiE-#5zv^DC~qHGp#l$aH^|nt!++cskYW; z*~(e!b1@(10z#0^_u1Pkb{&rP;L!vdO@Y@F8I5b^R-OBq_c&4OB z+vViks7`E_N4fDuA=+-IQG^8~BA7svWo-Q_EqLF-yfv;e1vGORkr*8178T<-E1ucw z2;cdlX`K5hHX6QLHtS=iA1kt}>t3TfHQ6O97;z-(^!#pF_Cm5gdnG-q?3FbB`pR^~ z{L_pVj58i=Urf8nbiM*t()-evQZj?*TBoj=z=Mf>ka09wRdXYWqx9_HL-7Hbwiny>pKgk)!wQ+ z{|IB71I7{kTXYY}xVti~O>~+tk@hQVN^#y$->QeI)?H2tbO%;yY3)P225%*BP2Hsn zQQDMe#(#6|Q0cKah8|1y~rb(tA! zGg>s|+&VEvHmTN(M!&YcL;FMNBJWvHoYzUh(=uRP){@>TA?DjyZDL}_s9VO_(v9Sz zqNTkhErV>%{ls&Y%=Fo1U*4`yWNbCI*H`zNzYgGiF!^zgZm=jV?^GUsdCB~)FCa8lKp>|9BH|RkjwvyXcb*xx-a4&Rn%vh|7$+hTYVG&LjM!|$}>8Fg-%4McVNr-+| z(wzH!Npod7llnY(6Zp!#iyQ+pUK3CLt?6eWw-Ye41z3!7?|EH)Q%lm^jV&$#6OwJ7 zsnIY;nCp0rYI<71US2g_XIqM@>$mawkc>psB&|H;nP;S-8r61caYwQDON|(W z$9~2vGxiH!N{=phEn=Cu&Wz5Cq0Y3Nxlde5iPZ&dEo~IlopCCrRz0|`@r-GXh^(YZ zGsdRY*F!#IAi^vm*m{^)e3QUkijk>7mof*N+9Dlx>oULk4O!?hyzRl{SOpTB4c~N= za@CO%&T2TbAlVkeLQneC_&FmaAo8iVx@+8NR805IfvGr|od*CG0&Z6qs zMQK^ZC^PGly^ywrt59}XNy@h{5}q*+2I(Qx4!bLuE3Ra5dxR9b1&y)E=?6{TymcE#zoc>7g;Zv9;)$` zogl1ktCx=-*{SgCXee6^r^{PWl!|VD64#0DTV2zjPq{^_F*=qLFhQ zHrf#Ovmw_-u63>*SGfkEzyd+h63Y#fQfZ*FftnUf>izYM`R#yaL!dNZV=v9)w-=cQ zOFy+MVWm-@`vpv2SU=)seG9{k`1A73QuAx){OXzG)YZ>r&HjX0amhF}95DOq3w(PO zv-1OH3xACt%r^Zh>o4LDI~ucB z@OwbO-3HA1aCc_FT{mWb$6Zsv>}t$j!0eWQ+5MQs@f-DfpL?7@`adZ5#qUDN8@L7T zfgyNX!h~yo%QtD^Bxr~I;9NKpH+OS95{5v2uMqAA7=!`%DqIfBpac$v@$fEw+c};K zKZ82Z{z=cHupjwY0u}Hpu7}_OxD#%HOQ9Fu2l;K{SYgk9_8Vh%B*zKx6!|Z|3eKzG z<8Urq5BI?!d>=Qjar_nNAJ@CXM`0eE1l!;>xDD=uOW{`_zg_Y7G--VTUV-n!8*m@I z0Czw)TnF-7i2KLjQhPne#(Nz3G8N=^s#-RC*(USaMrsaTu1S+ABZe}?muw5#X0#kP z&E}hTwR2|c&)%uK+!d|KhWb|B+fv`PSF4hI#Y{b7uhzHI6XW`Rd##5b>SphRE_BCN zB|3Cng?4*A?aDaomOLALoYs|SZ|qUWFJHH2`KsBoOzeld(s9Z3==g50dClj)#8B$f zF3nuVf!2Gh_H&p944FNnmWzt+j42-qcPizRFT6ZnB<|@^F-y)jouH-9V+isz=* zL6q=L%E{WP! zMz2b3C||dJO-<$M;I>p39XEWbyCf)7&R&i6`h(f`ZWJ7H; zBN4t7UAw(GDf1qks<~0#N-Mqz-Q3(tlcx9zbThA1oA?TJb2^dO%9o&-AmW2V7pms% z^64$bce2B=HrrSw*Le=X^rRc>+nW_%%qCR)9;l?p!ZZM9r!h+DJGnZ}<*;+d7?^H7Z~Bs3AU30m;I>wq8LsAs(J9qgdZX=H^T+E-L# zg135VST(mM=?`9Ha;+`JH@6wMk#6p_ypq?)?Xwi$)DDD`Lix5I3~^^mUYV**Cs^ET z^yAByIS*8_z=m)BP}SA8GarLjmTqiQd<~rEOp#`iN|quRt3>;@7SuzxX{kFp#|7Wk z>u%|+HDge|9L}QP%@hsv@LL;sz9L(EiJa1!Xzc1t_*TZ#A*6*2Ktu?LFPYai>Jz>| zZcFz}YJE(3NbQO3TliABPNCc$-z?9Z*Ctebs%2VRdfN7u_GyGTO+WT&tuv?1oMsAV zp1sVN1s#M#*pjGEjb`7~DdOJ~bP|e#{^pjTbvOo|0t461pp#Gt9lZSIT|>~t&tvP` zjl?%)WYvCmK;0OlN-JnRXlvOHo}{RxXTnAe#%laJ$~RImkFUBJd*%w5Kcbw-J1kuQ zu+vK#HYYlKv+w1HTiK)@37Ar|Ai@}`9#?A99?D3YyhJIJPbMVv>y#Ij?ZO+!t6Ca5 z>N|Q^D$|-)zjK)xvBk1l<`QLcQMcY>f1+}r|1woP2uk%Xu{^{Pqz3VSSvxVy?ZFy5 zG22Z$muvY+7`;oxYYrrNuNH>PVfg-X*tx_W5Jme)pb#KT6!; ze(~(tv+eU%OXR+@&v|9}YggU)+I6?Te%tjrjQl@4`1yrG&c(mEHfIhO=ATkCjvODa z*^-D?QMI&mwZ$t+N-E-f9&Bnny@j?|s<}9QVa(%Llphl>pEq@Uyb~W=65Xs%6G-4hVgMm z$%$6~-lqB|@ztw0O^r)r{$0!L<+2XGDKkEv@~ho+dvLE z17kTbmIGrsFqQ*jIWU$3V>vLE17kTbmIGrsFqQ*jIWU$3V>vLE17kTbmIGrsFqQ*j zIWU$3V>vLE17kTbmIGrsFqQ*jIWU$3V>vLE17kTbmIGrsFqQ*jIWU$3V>vLE17kTb zmIGrsFqQ*jIWU$3V>vLE17kTbmIGrsFqQ*jIWU$3V>u9+1EN@fUka6gC{1XZISZvo z|Bat$78p%8Lxm2rcZp+uT*b?jx_hbU5P2Qt7iXdVVaHh@NBa{m{<(iNx)PN7YyBm& z)H`pLO1xqH3SzbkNZ16Yf0DM@v+r8m+}zA@Haa7Wz6hglVU_5RKz~H9utYpW>0vnK z+vAFxAO+pf3+F>0Tn+soar?R{^eN$qSn!GI+^;Mb zEo;7+QdgFXKa)-@lv<*-O{3+f&`;ckbyDasurS5P=qhQ_-=--PiZO2#RpjW1KzT!h zR#GW9j;<}VLWttz|KERpx+NcN9{5KackhyS_N**b>anG2uxFW{AW`LD)HxKRzofL3 z{8Tv7X0IGoRQx*p2}a=WA>QU%O)V-wnZ9iQ~Hd zUDYST4-@l+OS;=y4_YmnJac-<-6J&E+> zC5!hMzmSSP(bmw~6DNT7^rFdK9qkL!jaw3J_33F^#YsBZ+&K+Jb_?p$ZPT~SoE&ef zZ*OVl8(ABIu@O`}z7X9m>CQ?N)7j7_>?E|=6SO~krcp&EdRpu?CR(2&YN?v4(8PjH zs?CXX#xiKVTx&7owpS&#q1~lb{w|tapRR1*mgL)EljB`2^0mG+_tsqBnodlP&&Y(c za7N)+7S6~?)4~~{m0CEfYt~J(@0xw(oEzp;98-PFv&a1Qn2LGp z<{dtN&ioAv8Wudd;O7gjTztb~Ri#uM_Z2g%XO5e@&)g038|VLX;fh69EqZqG%c2db z&ZJ@7ti5Md%&ne#)Bo4rSw>q~cJF@eqGKbC#0Ken`njK`LuqLN>5}eL8kE`~9SYLj zp>!kCUD72WY@|axzqR;}alV`}&bRaF_~G4-SJ`Vl_dVw|ub68o*6}-3Yog0P>-zEg zqh3ij^>9_j^MB>gE9-T1{w6ULD$b83>LE3mmPt#dXVp)e56!H?upFzXYrAFLZ{1RX z6`quHKfdSo%4}u6(pl}Rj#V3L2aGdDZnL*J!mMmJ;vN5Dk8!3t+nsfOXiX?2sON%` zDm9eaOI@Xr(o|`VbU->KJ&@i?QF3p2sQjb6N!};Fl#?lGmCqDav6Y%iGo`IENExS0 zR+cHhDZ7>P%01<=602rXKUFKLU#k7o@6|+gle$;Er@m4@s9Ci_T1l;vR$ptX_0dLY zM+B$LS>u&nRy+F*+GNjd8{tV}Y^VILb5pZTxG* znz_spre;<%o0zT4LFPDfvboaSZtgSxH2*fAn`uQZkza)Gr>7V$#)wT~uedFqi+AD^ zE1y-w3alDdJ*&4h)S73lwYFI2tXo!cJFA`B7ItO3hTY!oXAib#+RN;<_F?;yeZ$V> zq<2lXl()dI7qkw33yy@(c~>Z;@#BoVNBL13sE^fu)Tisq^$q$+W1?|fG_^WetE~yP z?xgjKd4~6I`2J6P{4>L(3-SX_v$HZoS)^Q1qSQ-jC;ggn&nW3`ba%P0-QoTe|Ac=q z{5sb|A-?`F)LNP%U6LM4W92(?l#*KgLLI5TP%CJ%-icQ(XPh=(ntgcE3!;!!f!7{t z9kA|LY3+RWD0`B9#6Dw3IgOlo&UNRBQ{7$cu60kkmw6`B>)0=5JLO&URR54ankR`0E#P;1QX{E_^g*gCH<4G#m6fVgQXQp% z(odPA>{E^?SCywq4pmbdtE1KBRC^Yx#?;Dc-LzraChd@RiF$dh?bg3HI*4oHA5p^c ztnyYL>yUNHx@qOJE7@1JHhpmjIWn|V#utY9`Yo0~n%)8=Kf z5WQQ@>g4os9ypEMRNg`_r9a&t67a>Xq1pV7A<}GVgS1yVBps73NH?YD(!WxSoL0^& z7nWt&ldH(}ja;XK>25K|)q54u4T4`;cc3OL-<=1=aC-vKUUZafB z%9w1NGM*Y4%nTy0&_ylLT=WtP#b2VLHQBmim9eXG*KtmIXQDIN-RC}cO|Jp>dfiK) znl}2qf{+vy>GiL9M_)(U9FHC3~w84?youbVK4VP(awJq9C?SOVvJEL9JZfbvNNxbh5TAZFn!n z^Xi55Qo5mgdU^c|y|&&^Z>G1^yYgIp^?~|eeYifF-bvIa(>=5Gx%vWqiM~Q#LmzF? zx9Pj|eflB&h<-vpqhHXk=+`-m`}!k2Nq?@t*5B(PBi2Y^q%q=+Ohz^%r;%XfHwqiY z4b!M)bTft;yN&YZ6mtuxpowl`l2|MDiC8-?2-wpeXK%3g*w5`WPC-XFTb+~64d=dN zxFg&rZUOJEXZaQU=Kkz(-IwC^8m*PnzSJ6Ny}3zK|AxC6pikgF_Ur%XnT_7YbmN>+(yVNDHz%4Kz}chBo_A(6 zI6Fe@7ahRR=T;HBn?287Y2UG*+8v!UPNLh%+wSG^w}<z4}rpnA|G=ob7Fgyu$tsX(Z<(oGqq zWKusOk zrzE5=VFw4Kv(h6e77X*{a&c8t#(3jTBa1oEd}XHKjOyC4PG;vbr>fJ~ zY3WR&CsjIap1a4*EWz*2D=mZO(XqI z!JuFaPqY6c$GHA+mQ0tHNSmbVQj+vaIw)6BS}I+X-f*ws${1x59Ad7rSXrfPRJJL5 zmBY$Oo>x*U!DZX1ebnLVB#`|m_mD)NXVMC4vi3FHD-%p>sxgmw^4@4{wlf!)zniMC z#8R-b(d09A&?jS#M3xz0eDox6OItj#y-c>}+;|Jpvwa$Ij`ra)w7< zDay_4wsx1eFI?U0<&E%Wd71qJ;N3$1te-!q6D;7CqeIVmT}>Jyos?ckS>^h2AEl)_ zQ@yTM)@p;F*Fmk+%mE7qIn7vX>;y@FH%=JmjjP=ABjcIz*2rNNGi#Y`%|7N>b1rvs z(0pt@Gm8jGlopjl9no5RFUE`0B1yawA4Hs$#>#Hxv23ff)zeyM9kotdkHNh3c4oVn z9oP-+F825K0vO|Q*kY8E-6`M{bu`Cv$~!H%-Gk0G=eF~Ylh)1Vo^cNIffN`)rQo|@LNGPh8=MX<1)=!p&>@~Vt&|I9W=o$lN7_n# zq;I8(RK{xQzVw=JWi2HKaz)tsNYLq^d|tjPr&Dq(1(b=(JY|V;f&P4=`Mt zB6+MP&SN zmn6B`B9uaJe}o_E8XcK|FO?MPOWuDiv!&UIN!`c%&Kz!zHo_FFsAS?(Nn{&F(HVYc|8!O;B8%WVcliN{o)^-GWkWX^c8T8=zap4!f&c#sA5l9)7O5(GgEhk}659xvO(L z-)%XClAttE+9}hNI42Vwk<(3Z2f5?jK5*4DUYwuVFXFca-FKi(qxp98Q0S?YQQjaA zM#)ZAuc}d+(AsES^`ZJ={i2@HaE!)A4?{))9yQ-N<=sI+XjgRT5r3|r6bA>*t1EhG zy*j+JGmP^Gc+Dc%$6jv#Y9F-E+PC0B|JiAs zPn{x;=>$$S=PReZliFS6UZdyVG4Hd2ZmM4fKG%f1{L!E1uk&~L$NcMH!FxYdkS!<} zXhGSaX3#X~2qPH{CM*cn1-pV{!Ij`a@S1rO9pRSAq)bvic#zL2came7278$V*Ob4R ze<{_hsEf1upZY^sa}-^i-zdqsRi-LCqN(2->C8_}g~~~5S=RT~8EXuRv5zl;(m`cj zdrGh)2wneJ(-|d0S|YEI*Ki}Jd7X?PjHy&nS}9$XO^T$qcDuR#!hS|lbi{A@#0_KI zMX$Wyfm$jPtPVC)88MN2{S3s4S4t>Z)RJmptvpjg(X-KSS(&EjB`+_i^*QIbOUKY3z(PubmJR(acxXrrI36CV17& z7-T##dy2kdpcsrRFdBZDC?<>PFtfRI!4k0o9=Jhl5!=Kr+=Bb!5!ipqkzB{^?+#_! zPjXkgo88j>1)Q8`{yV=J9BF-U7c7e5oBTteX-wx`FzZ8b!s2Qfb-A`td&tC_;`aj& zVj{dGt>mJ8qm@ERAKaOEts?VkCdw&EJ829vXPb-6H9X5He2i$3Q3%mi3=lu^z7C1^ z!nev%e@}2K;_)g9FlnyYJ)N=6QuOyfP9e9c`<;8vtx4ZZM(geNpZjIuM&p8?K^T}E z7!wm(fzOjysv>=lGCeO{kze8G#49W27?En}xXLa%N4l5iU+=v#&XnSv-|#ywqG}ZUeEdfmg51bRv@| zB1(z!;&bM5L(xohCcVInKhgZt3~mz_H} z8_%2=_Y*gdTas!h=hnjEXzOl3^QH5$;p|lR8hPu`W=Flt)aq0EI^^f@^Z6!yUCnRo zxAS}YgZ&9$;;(*uP%QW&XvcIP8B7Xhz+6`ZTY{Z*^I1HI`@!?zUHGn=#e}JUD7lm_ zGVvwJl*%#n>q$+dZqjgRj5JO9Nm?eYMUxzru1e4F7Lv;uOfkDw zl=^I_b=1DorfOTYBicFbjuz7M>5g7guM30ktIyDXg2k`YkHHR}bLTN=@gg8g4OCE5 zqouLg*lS!cZsKdDfNwcCr(JO%Cz{J6lPF%~5haBu>WQyK8_@~3ZUFZ>QEcT#-{9+1 z<`z3xU95iAENdam;t%TtF2@~uAO#9u;A3{P2iS@BQn2c({Q}45Q`C7yR6`G^uQL=E zWRbJYIqh6vj=go#aet~?-tFuTp_ga7%bB0&-IQK-c;;sB7|Qy&mk~5J{L+3cec1!5KZEoWRw}q~-?~>O~aNaJcaybm@O;W=+#9^mi*0YIHzTw;d|zTX&c{#hnjh{|$Zi2VCf)8{$lJ zdx~dyb-lLUkKPjR4>}_`{m{i9kF%n)r7hn52C!b{2MDbMNj!fJVX{abY^C$>agr|zK+PpOyHM`~&U)~QaE*4DF(RjEAifcc(Aj^Bj8-nvk?*Wut>etJ{B{xBf<-mNnd@l(&TPx? zc%0r8oaJchtsnewE_!>jyA39M8i($=o7#)_@_A*wp59XLl6TF^!Y#z zl5NbUf0rt2l+DTx?=E5vj%!1d{z_b;rYfzYI;edELBY zMu`fdJG1U5=G<90$!qbih_=#M8Lh%-(fZ7|K_KJF$ZY%1iiH~tvd7qS?OpacYVd=d z+KG2^I(gBdRh*7aH|L^L#~aAB+J`E8S|0f>COV~|xkTQr5 zvQnD`g5rT1*g+YvutrcX=o8EgmVtvO!~WEon6R~n-%xUIwSi7dj)6hBlcG?haB#F{tJf>$P1gZ55dKOZp z{CY81rG)~h6wv^^m|DyA-}SrtJ3TkEs)F%3)2c;;rTmHy_0&-C`Rl?*#&Hin;lQ3U z@0pKqrt%3}d?D(JR-y-UY9`#{S8*8baf2HvVChyZtBp0#`jLF(7Z}GeE5>es67EYi zzq6C$C`|-SUpmR%4DP3H3H-P!ZcCKF4)>1R!0UlhKH}YgJ!AkQr~0e8kH7r9K@0f) ztYBrZFZdm{AKDeef8*_=4`4`+R1Kf25t&^NX3${HeLNY_Y-xUk8Elbu;@2IO&PbP~ zzsQZAqmpCfBDf_z<$m(FFoP-bVtD*oT)YeNTV_@+B_GM&=P5g zk*Y6YRkymK!{#%&Rz_ymIqRX7j`U7Py;cN;>)FjB%wW7d9bUK2-eT_{$2$Y2+_N9q zukmM6!}1C{B^?!)?`yoLpPdEHI?~Yn&N=6)6Uz7_bcElzUNo+Yx|Apt#1B6eERYJ zN&l+<)c@B{ALIh>TLxY53I+v3gHgdmZh08&VlDYASYCH|pgf+0c8lkfb_EnZUo z!vA@r#HeX;LnO5=7&ewEFb5p_1J3tS%}(l5So;Durlr#0p9fr=%?&QIs`LN_nf zSAk)Bn4cG5Be(H0pP?qBjpXP_4OUVK{O^XNIs#91Ib8oL6X3lOW#)_YQzx^ZIU0Vy z-u%maV!kmy&{0LW@y590t8m(`iMvdNS0b||V18d)ol!eOtx<5l-?-(I)&m$yI@Db@ zv`*^sonKb&Pe_!jnQ zPoS|LMCM6m9647lr#4YLFjppUBP-R->JGT!9cFS2GdU}%xkCcl7}ui{$$1#(X5pAE zM|U06j-kD-Go#-|61Tj1L0!h@4m0#{&NfgV5=o}REPac{=@<#bLc_+Lw z1}CE^PDUB!YqIEBDB*qd%|+#*60Ii3KPdtN`s(LkVAwq!$~+pY&W1sSUDTuMpXy)g z8#Rsgzq8Y=k#yq%bLOSq-neB%n_0{vF!hSe_`3h&(S_&BDo!yQr>BaVVBcV7{W_+~ z4e&0PRf(B0g6e-`sdguOApY{N_CNUYS(xdc;V{eOmH~=qzVpT@3s$vsd%~24xuf0b zoaZWcyPE=>DoanaB<1f0PR${k+yo1~M85eDotob-?rVNkzn? z(}CbT3^X=WoHH#B27M)Ur1H;_Ld20`x2M`iFgG5{pTjZ3Iomn#r8-Q!qdEpAeiV;2 zgO(2_K8PB?`^rhReyl%mWA0{)@TO<{~ovPF79YP(=rp`-HXlDoXKr7 z$$UY|7$?$;VxpX=4tMN;M*N9faJ#r7##@K+ss4d`=f#05hoY~KlAi~<=K$LS7*BQQ zOLX9H=OF1Uzql*iU)_W5Z8yn%>t^*n^Ge{z*Ylc@aD0zuS>tW< z4ls}3d3k&tB<~J_|KeZtU;Al-%t3yVG7SuG0bZO6E~DIE;Z4PcIz}-26C9RWQg^iZ zHTX|RE=9eykynBW;Tp@M&4PIQevOQWPNHsED?yWqpO$8QzZ>WsS9_T1%}} z)?Vwfb=OL=qU|&&@7ieZukGIUc(l%0`z9`@Am^CH6kSEq@z}{tLN+|IY4Mkv7A;uB zbG#~E9j^^M=UcMQxlGI5-buRr2@|skeLet(WURl~-|QdsPx}w3!en^qdQbtz*@=X& z552xPI2c?FZiRVgLTpImtW)BTxbm9v3a4v&)slYl5->#9>9anXp zwGjv79(pm0U6Se5gdK#j=*5-xe)}Zu(_MNyjg#N004M3=Om}{9_M*IBIPtE80&3&V zadUWiVH1mbt~P#7fB5k^&ftkKdH!lBm9X0|0{46g z`PnvhlTNU&bDIRMgFVdNgjUHy*Z%JGX8R(>E8}(YR?&YCyl&{^?fBu%aLi`lqsE5U zN~*Hu;@F=gU3$PNkHrz%?-rv{D|nN<+5RbCWp5)kys{Tckm|F!a7!vgzSfM~ z>KyYzQmTUg`Lw5+#GIW87cz}{)XF)qEXgQsHpWp_tSGxa*pn51u2=q2>TFua2))+RybR8YP*ftu{p-3S|)axI(h~CJ@_UU{1oIO`{2sAKJIM| zj*Vo|X_)=rNge5agBdT_?VMD1q`eGja&Kp_t z@z0Myf8Unw$N+k>a-8>GFpsrheg$~;cc8fI*zQ^MWo%?m zCnObywT=J@x^SOQwKrOrPfEBH+2Jr%%?{*?lbItc**L6$602ZO;m*3EpB_3Tn4x35 zscZ@C^{U{c9ssjLCqCX!5tQjhW?~C;NR*lqEdEOk=+?ekUEH}@bn9E{dI_63K557n z^1RAyxGg~irh^UDCV4w#HMZ+Iqn!HgNOu+!{00uL&s-Vf?IdZw>&5zcNe{32#mLI0 z!s9>oZ*pFDyR=3*uG~<0TdAd41VLk($!Ol%O zy(WFW-nC#iZ@es|aBbl#agn<1$Ckh;@_q|vM>|?uR0Pg-tw0uwW z+zYEbPG5ps!QH~ftHT_7%$C3+=2ToL93NH!Wft@Pt})3Apq)nJ203gLm7-Sq>1*-P z_Or=R7d4XBs)OtGM`TYgF7n^tog?knLN((ey>x^$v^9yGLHhqjP1IIv$MiBJy?x-F z;ho~9_`J)^iK4Po!7UVd7bEbu!cG10eYBL1$O+0bWuDrA-9}wcZ^}%&MpkRIXA~*J zGiQ>wh-tNnlrUF`>efW- zJnmfq`-EMXJ=)Xk=Vo*lu%FtRnjT6W3=GDy1H!Br92eP5?SK}2f|@CU*E>VrDi=^L z!2<(hG4p1pcw?1|sDyoXCen}#&KmbR2%q4c#cSq$C4Rj3SvU#ZNFa`?@6;7qA^kk> zr@PS(zp(%tDtw(5qVm?8D5$822s?N^-9-wf@B0%f4GTe8i9E zRYK|jg3puY;tW2P^C^`;@XTrs6!H)7v?5IL>}GuuyQS>gJM11$huOb(`jO<+_rCG= z`*)bxU*e)158vOek2RS|Du!1+nVUFB?+AH=Qa~@u2H-&)3>|F#0j1l3&5R-V`}@RV zt1H`avtgp~@TMsr-5B<^Kh{D8sU5n13Y+kEY7msqRqqWkD;e-6&GU$DzU`NCWwDSej&h`Jvq-R=19h=$s zH9h{Fvn+h4NpYbi{5Z%iV0tZ^mPf0j4ach~h~JjT=KMx7xWlAGHzRvbsm)KAC`D29 zWl7`0$!j~aBV4v8e&;}QusI!;bkH0n7UMSO#$_94Ew(l@tIk+W*>AYQM#C&n{wh1< zuQ~aU8|$XPiGS_BC-sT-Qg{Wu;$CTdv97SU58f9fK3T}k*!8)5-RR769(fcV%2pi7D{^+FFlxN9@-6f9A^rDG*$I}uWs@@-PdE{W zJvDp96+y0Ee4Zm8-uYK(=V|y2+at{Lz9>n?)f%5+5Ug{t^~y?V@3ljy!#YkAP_hf@ z))X|$JZCX!?*{VTJ@C&H&Uv2hE*j<~xkG9<-p#^xO865NpTk62vfD5oE^?i1-zYDq zR|p2a58pNg4%26JMPrzE52o=rzjH92G-qx2x#N?CTA@`!WQDm=DPKff@=>@G$8nLO z$!v>~Ka?hYNTi>a@i~ha2D)v%&S2O~QKcxgL@Ip;_($^1@qg z7E&CQ8Qzn9zwmbFB5xz=`;>P-!br<D}m6NEHm%KNB=*X*#QFyqaf zri;@ymM+}Fmi2u!dc4TSzE)xO5(WCQ6|P!OHduzUy)qd_xB$%G0zOcXyt*Hc3 zt7gGqcJb!28N7?sK2$n+YzO)(_u&0f}uYD L|6l*lPT+q5-+$id literal 0 HcmV?d00001 diff --git a/mimgui/dx9.lua b/mimgui/dx9.lua new file mode 100644 index 0000000..e523039 --- /dev/null +++ b/mimgui/dx9.lua @@ -0,0 +1,171 @@ +-- This file is part of mimgui project +-- Licensed under the MIT License +-- Copyright (c) 2018, FYP + +local imgui = require 'mimgui.imgui' +local lib = imgui.lib +local ffi = require 'ffi' + +ffi.cdef [[ +typedef struct IDirect3DDevice9 *LPDIRECT3DDEVICE9, *PDIRECT3DDEVICE9; +typedef struct IDirect3DVertexBuffer9 *LPDIRECT3DVERTEXBUFFER9, *PDIRECT3DVERTEXBUFFER9; +typedef struct IDirect3DIndexBuffer9 *LPDIRECT3DINDEXBUFFER9, *PDIRECT3DINDEXBUFFER9; +typedef struct IDirect3DTexture9 *LPDIRECT3DTEXTURE9, *PDIRECT3DTEXTURE9; +typedef const char *LPCTSTR; +typedef const void *LPCVOID; +typedef unsigned int UINT; +typedef void *HWND; +typedef signed __int64 INT64, *PINT64; +typedef unsigned int UINT_PTR, *PUINT_PTR; +typedef long LONG_PTR, *PLONG_PTR; +typedef UINT_PTR WPARAM; +typedef LONG_PTR LPARAM; +typedef LONG_PTR LRESULT; +typedef struct ImGui_ImplDX9_Context +{ + LPDIRECT3DDEVICE9 pd3dDevice; + LPDIRECT3DVERTEXBUFFER9 pVB; + LPDIRECT3DINDEXBUFFER9 pIB; + LPDIRECT3DTEXTURE9 FontTexture; + int VertexBufferSize; + int IndexBufferSize; +} ImGui_ImplDX9_Context; + +bool ImGui_ImplWin32_Init(HWND hwnd, INT64* ticksPerSecond, INT64* time); +void ImGui_ImplWin32_NewFrame(HWND hwnd, INT64 ticksPerSecond, INT64* time); +LRESULT ImGui_ImplWin32_WndProcHandler(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam); + +ImGui_ImplDX9_Context* ImGui_ImplDX9_Init(LPDIRECT3DDEVICE9 device); +void ImGui_ImplDX9_Shutdown(ImGui_ImplDX9_Context* context); +void ImGui_ImplDX9_NewFrame(ImGui_ImplDX9_Context* context); +void ImGui_ImplDX9_RenderDrawData(ImGui_ImplDX9_Context* context, ImDrawData* draw_data); +void ImGui_ImplDX9_InvalidateDeviceObjects(ImGui_ImplDX9_Context* context); + +bool ImGui_ImplDX9_CreateFontsTexture(ImGui_ImplDX9_Context* context); // replaces ImGui_ImplDX9_CreateDeviceObjects since they are the same +void ImGui_ImplDX9_InvalidateFontsTexture(ImGui_ImplDX9_Context* context); + +LPDIRECT3DTEXTURE9 ImGui_ImplDX9_CreateTextureFromFile(LPDIRECT3DDEVICE9 device, LPCTSTR path); +LPDIRECT3DTEXTURE9 ImGui_ImplDX9_CreateTextureFromFileInMemory(LPDIRECT3DDEVICE9 device, LPCVOID src, UINT size); +void ImGui_ImplDX9_ReleaseTexture(LPDIRECT3DTEXTURE9 tex); + +int __stdcall MultiByteToWideChar(UINT CodePage, unsigned long dwFlags, const char* lpMultiByteStr, int cbMultiByte, wchar_t* lpWideCharStr, int cchWideChar); +]] + +local ImplDX9 = {} +function ImplDX9.new(device, hwnd) + -- ImGui_ImplDX9_Context* ImGui_ImplDX9_Init(LPDIRECT3DDEVICE9 device); + local obj = {} + local d3dcontext = lib.ImGui_ImplDX9_Init(device) + if d3dcontext == nil then + return nil + end + local context = imgui.CreateContext() + obj.ticksPerSecond = ffi.new('INT64[1]', 0) + obj.time = ffi.new('INT64[1]', 0) + imgui.SetCurrentContext(context) + local imio = imgui.GetIO() + imio.BackendRendererName = 'imgui_impl_dx9_lua' + imio.BackendFlags = bit.bor(imio.BackendFlags, lib.ImGuiBackendFlags_RendererHasVtxOffset) -- We can honor the ImDrawCmd::VtxOffset field, allowing for large meshes. + -- bool ImGui_ImplWin32_Init(HWND hwnd, INT64* ticksPerSecond, INT64* time); + if not lib.ImGui_ImplWin32_Init(hwnd, obj.ticksPerSecond, obj.time) then + -- void ImGui_ImplDX9_Shutdown(ImGui_ImplDX9_Context* context); + lib.ImGui_ImplDX9_Shutdown(d3dcontext) + imgui.DestroyContext(context) + return nil + end + obj.context = context + obj.d3dcontext = d3dcontext + obj.d3ddevice = device + obj.hwnd = hwnd + -- set finalizer + ffi.gc(d3dcontext, function(cd) + imgui.SetCurrentContext(context) + -- void ImGui_ImplDX9_Shutdown(ImGui_ImplDX9_Context* context); + lib.ImGui_ImplDX9_Shutdown(cd) + imgui.DestroyContext(context) + end) + return setmetatable(obj, {__index = ImplDX9}) +end + +function ImplDX9:SwitchContext() + imgui.SetCurrentContext(self.context) +end + +function ImplDX9:NewFrame() + self:SwitchContext() + -- void ImGui_ImplDX9_NewFrame(ImGui_ImplDX9_Context* context); + lib.ImGui_ImplDX9_NewFrame(self.d3dcontext) + -- void ImGui_ImplWin32_NewFrame(HWND hwnd, INT64 ticksPerSecond, INT64* time); + lib.ImGui_ImplWin32_NewFrame(self.hwnd, self.ticksPerSecond[0], self.time) + imgui.NewFrame() +end + +function ImplDX9:EndFrame() + self:SwitchContext() + imgui.Render() + -- void ImGui_ImplDX9_RenderDrawData(ImGui_ImplDX9_Context* context, ImDrawData* draw_data); + lib.ImGui_ImplDX9_RenderDrawData(self.d3dcontext, imgui.GetDrawData()) +end + +function ImplDX9:WindowMessage(msg, wparam, lparam) + self:SwitchContext() + if msg == 0x0102 then -- WM_CHAR + if wparam < 256 then + local char = ffi.new('char[1]', wparam) + local wchar = ffi.new('wchar_t[1]', 0) + if ffi.C.MultiByteToWideChar(0, 0, char, 1, wchar, 1) > 0 then + wparam = wchar[0] + end + end + end + -- LRESULT ImGui_ImplWin32_WndProcHandler(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam); + return lib.ImGui_ImplWin32_WndProcHandler(self.hwnd, msg, wparam, lparam) +end + +function ImplDX9:InvalidateDeviceObjects() + self:SwitchContext() + -- void ImGui_ImplDX9_InvalidateDeviceObjects(ImGui_ImplDX9_Context* context); + lib.ImGui_ImplDX9_InvalidateDeviceObjects(self.d3dcontext) +end + +function ImplDX9:CreateTextureFromFile(path) + -- LPDIRECT3DTEXTURE9 ImGui_ImplDX9_CreateTextureFromFile(LPDIRECT3DDEVICE9 device, LPCTSTR path); + local tex = lib.ImGui_ImplDX9_CreateTextureFromFile(self.d3ddevice, path) + if tex == nil then + return nil + end + -- void ImGui_ImplDX9_ReleaseTexture(LPDIRECT3DTEXTURE9 tex); + return ffi.gc(tex, lib.ImGui_ImplDX9_ReleaseTexture) +end + +function ImplDX9:CreateTextureFromFileInMemory(src, size) + -- LPDIRECT3DTEXTURE9 ImGui_ImplDX9_CreateTextureFromFileInMemory(LPDIRECT3DDEVICE9 device, LPCVOID src, UINT size); + if type(src) == 'number' then + src = ffi.cast('LPCVOID', src) + end + local tex = lib.ImGui_ImplDX9_CreateTextureFromFileInMemory(self.d3ddevice, src, size) + if tex == nil then + return nil + end + -- void ImGui_ImplDX9_ReleaseTexture(LPDIRECT3DTEXTURE9 tex); + return ffi.gc(tex, lib.ImGui_ImplDX9_ReleaseTexture) +end + +function ImplDX9:ReleaseTexture(tex) + ffi.gc(tex, nil) + lib.ImGui_ImplDX9_ReleaseTexture(tex) +end + +function ImplDX9:CreateFontsTexture() + self:SwitchContext() + -- bool ImGui_ImplDX9_CreateFontsTexture(ImGui_ImplDX9_Context* context); + return lib.ImGui_ImplDX9_CreateFontsTexture(self.d3dcontext) +end + +function ImplDX9:InvalidateFontsTexture() + self:SwitchContext() + -- void ImGui_ImplDX9_InvalidateFontsTexture(ImGui_ImplDX9_Context* context); + lib.ImGui_ImplDX9_InvalidateFontsTexture(self.d3dcontext) +end + +return ImplDX9 diff --git a/mimgui/imgui.lua b/mimgui/imgui.lua new file mode 100644 index 0000000..22ffff0 --- /dev/null +++ b/mimgui/imgui.lua @@ -0,0 +1,2231 @@ +local cimguimodule = getWorkingDirectory() .. [[\lib\mimgui\cimguidx9]] +local ffi = require "ffi" +local cdecl = assert(require "mimgui.cdefs", "imgui.lua not properly build") + +ffi.cdef(cdecl) + +--load dll +local lib = ffi.load(cimguimodule) + +-----------ImVec2 definition +local ImVec2 +ImVec2 = ffi.metatype("ImVec2",{ + __add = function(a,b) return ImVec2(a.x + b.x, a.y + b.y) end, + __sub = function(a,b) return ImVec2(a.x - b.x, a.y - b.y) end, + __unm = function(a) return ImVec2(-a.x,-a.y) end, + __mul = function(a, b) --scalar mult + if not ffi.istype(ImVec2, b) then + return ImVec2(a.x * b, a.y * b) end + return ImVec2(a * b.x, a * b.y) + end, + __tostring = function(v) return 'ImVec2<'..v.x..','..v.y..'>' end +}) +local ImVec4= {} +ImVec4.__index = ImVec4 +ImVec4 = ffi.metatype("ImVec4",ImVec4) +--the module +local M = {ImVec2 = ImVec2, ImVec4 = ImVec4 ,lib = lib} + +if jit.os == "Windows" then + function M.ToUTF(unc_str) + local buf_len = lib.igImTextCountUtf8BytesFromStr(unc_str, nil) + 1; + local buf_local = ffi.new("char[?]",buf_len) + lib.igImTextStrToUtf8(buf_local, buf_len, unc_str, nil); + return buf_local + end + + function M.FromUTF(utf_str) + local wbuf_length = lib.igImTextCountCharsFromUtf8(utf_str, nil) + 1; + local buf_local = ffi.new("ImWchar[?]",wbuf_length) + lib.igImTextStrFromUtf8(buf_local, wbuf_length, utf_str, nil,nil); + return buf_local + end +end + +M.FLT_MAX = lib.igGET_FLT_MAX() + +------------convenience function +function M.U32(a,b,c,d) return lib.igGetColorU32Vec4(ImVec4(a,b,c,d or 1)) end +----------BEGIN_AUTOGENERATED_LUA--------------------------- +--------------------------ImVector_ImDrawVert---------------------------- +local ImVector_ImDrawVert= {} +ImVector_ImDrawVert.__index = ImVector_ImDrawVert +function ImVector_ImDrawVert.__new(ctype) + local ptr = lib.ImVector_ImDrawVert_ImVector_ImDrawVert() + return ffi.gc(ptr,lib.ImVector_ImDrawVert_destroy) +end +function ImVector_ImDrawVert.ImVector_ImDrawVertVector(src) + local ptr = lib.ImVector_ImDrawVert_ImVector_ImDrawVertVector(src) + return ffi.gc(ptr,lib.ImVector_ImDrawVert_destroy) +end +ImVector_ImDrawVert._grow_capacity = lib.ImVector_ImDrawVert__grow_capacity +ImVector_ImDrawVert.back = lib.ImVector_ImDrawVert_back +ImVector_ImDrawVert.back_const = lib.ImVector_ImDrawVert_back_const +ImVector_ImDrawVert.begin = lib.ImVector_ImDrawVert_begin +ImVector_ImDrawVert.begin_const = lib.ImVector_ImDrawVert_begin_const +ImVector_ImDrawVert.capacity = lib.ImVector_ImDrawVert_capacity +ImVector_ImDrawVert.clear = lib.ImVector_ImDrawVert_clear +ImVector_ImDrawVert.empty = lib.ImVector_ImDrawVert_empty +ImVector_ImDrawVert._end = lib.ImVector_ImDrawVert_end +ImVector_ImDrawVert.end_const = lib.ImVector_ImDrawVert_end_const +ImVector_ImDrawVert.erase = lib.ImVector_ImDrawVert_erase +ImVector_ImDrawVert.eraseTPtr = lib.ImVector_ImDrawVert_eraseTPtr +ImVector_ImDrawVert.erase_unsorted = lib.ImVector_ImDrawVert_erase_unsorted +ImVector_ImDrawVert.front = lib.ImVector_ImDrawVert_front +ImVector_ImDrawVert.front_const = lib.ImVector_ImDrawVert_front_const +ImVector_ImDrawVert.index_from_ptr = lib.ImVector_ImDrawVert_index_from_ptr +ImVector_ImDrawVert.insert = lib.ImVector_ImDrawVert_insert +ImVector_ImDrawVert.pop_back = lib.ImVector_ImDrawVert_pop_back +ImVector_ImDrawVert.push_back = lib.ImVector_ImDrawVert_push_back +ImVector_ImDrawVert.push_front = lib.ImVector_ImDrawVert_push_front +ImVector_ImDrawVert.reserve = lib.ImVector_ImDrawVert_reserve +ImVector_ImDrawVert.resize = lib.ImVector_ImDrawVert_resize +ImVector_ImDrawVert.resizeT = lib.ImVector_ImDrawVert_resizeT +ImVector_ImDrawVert.size = lib.ImVector_ImDrawVert_size +ImVector_ImDrawVert.size_in_bytes = lib.ImVector_ImDrawVert_size_in_bytes +ImVector_ImDrawVert.swap = lib.ImVector_ImDrawVert_swap +M.ImVector_ImDrawVert = ffi.metatype("ImVector_ImDrawVert",ImVector_ImDrawVert) +--------------------------ImFontConfig---------------------------- +local ImFontConfig= {} +ImFontConfig.__index = ImFontConfig +function ImFontConfig.__new(ctype) + local ptr = lib.ImFontConfig_ImFontConfig() + return ffi.gc(ptr,lib.ImFontConfig_destroy) +end +M.ImFontConfig = ffi.metatype("ImFontConfig",ImFontConfig) +--------------------------ImFontGlyphRangesBuilder---------------------------- +local ImFontGlyphRangesBuilder= {} +ImFontGlyphRangesBuilder.__index = ImFontGlyphRangesBuilder +ImFontGlyphRangesBuilder.AddChar = lib.ImFontGlyphRangesBuilder_AddChar +ImFontGlyphRangesBuilder.AddRanges = lib.ImFontGlyphRangesBuilder_AddRanges +function ImFontGlyphRangesBuilder:AddText(text,text_end) + text_end = text_end or nil + return lib.ImFontGlyphRangesBuilder_AddText(self,text,text_end) +end +ImFontGlyphRangesBuilder.BuildRanges = lib.ImFontGlyphRangesBuilder_BuildRanges +ImFontGlyphRangesBuilder.Clear = lib.ImFontGlyphRangesBuilder_Clear +ImFontGlyphRangesBuilder.GetBit = lib.ImFontGlyphRangesBuilder_GetBit +function ImFontGlyphRangesBuilder.__new(ctype) + local ptr = lib.ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder() + return ffi.gc(ptr,lib.ImFontGlyphRangesBuilder_destroy) +end +ImFontGlyphRangesBuilder.SetBit = lib.ImFontGlyphRangesBuilder_SetBit +M.ImFontGlyphRangesBuilder = ffi.metatype("ImFontGlyphRangesBuilder",ImFontGlyphRangesBuilder) +--------------------------ImDrawListSplitter---------------------------- +local ImDrawListSplitter= {} +ImDrawListSplitter.__index = ImDrawListSplitter +ImDrawListSplitter.Clear = lib.ImDrawListSplitter_Clear +ImDrawListSplitter.ClearFreeMemory = lib.ImDrawListSplitter_ClearFreeMemory +function ImDrawListSplitter.__new(ctype) + local ptr = lib.ImDrawListSplitter_ImDrawListSplitter() + return ffi.gc(ptr,lib.ImDrawListSplitter_destroy) +end +ImDrawListSplitter.Merge = lib.ImDrawListSplitter_Merge +ImDrawListSplitter.SetCurrentChannel = lib.ImDrawListSplitter_SetCurrentChannel +ImDrawListSplitter.Split = lib.ImDrawListSplitter_Split +M.ImDrawListSplitter = ffi.metatype("ImDrawListSplitter",ImDrawListSplitter) +--------------------------ImVector_ImFontPtr---------------------------- +local ImVector_ImFontPtr= {} +ImVector_ImFontPtr.__index = ImVector_ImFontPtr +function ImVector_ImFontPtr.__new(ctype) + local ptr = lib.ImVector_ImFontPtr_ImVector_ImFontPtr() + return ffi.gc(ptr,lib.ImVector_ImFontPtr_destroy) +end +function ImVector_ImFontPtr.ImVector_ImFontPtrVector(src) + local ptr = lib.ImVector_ImFontPtr_ImVector_ImFontPtrVector(src) + return ffi.gc(ptr,lib.ImVector_ImFontPtr_destroy) +end +ImVector_ImFontPtr._grow_capacity = lib.ImVector_ImFontPtr__grow_capacity +ImVector_ImFontPtr.back = lib.ImVector_ImFontPtr_back +ImVector_ImFontPtr.back_const = lib.ImVector_ImFontPtr_back_const +ImVector_ImFontPtr.begin = lib.ImVector_ImFontPtr_begin +ImVector_ImFontPtr.begin_const = lib.ImVector_ImFontPtr_begin_const +ImVector_ImFontPtr.capacity = lib.ImVector_ImFontPtr_capacity +ImVector_ImFontPtr.clear = lib.ImVector_ImFontPtr_clear +ImVector_ImFontPtr.empty = lib.ImVector_ImFontPtr_empty +ImVector_ImFontPtr._end = lib.ImVector_ImFontPtr_end +ImVector_ImFontPtr.end_const = lib.ImVector_ImFontPtr_end_const +ImVector_ImFontPtr.erase = lib.ImVector_ImFontPtr_erase +ImVector_ImFontPtr.eraseTPtr = lib.ImVector_ImFontPtr_eraseTPtr +ImVector_ImFontPtr.erase_unsorted = lib.ImVector_ImFontPtr_erase_unsorted +ImVector_ImFontPtr.front = lib.ImVector_ImFontPtr_front +ImVector_ImFontPtr.front_const = lib.ImVector_ImFontPtr_front_const +ImVector_ImFontPtr.index_from_ptr = lib.ImVector_ImFontPtr_index_from_ptr +ImVector_ImFontPtr.insert = lib.ImVector_ImFontPtr_insert +ImVector_ImFontPtr.pop_back = lib.ImVector_ImFontPtr_pop_back +ImVector_ImFontPtr.push_back = lib.ImVector_ImFontPtr_push_back +ImVector_ImFontPtr.push_front = lib.ImVector_ImFontPtr_push_front +ImVector_ImFontPtr.reserve = lib.ImVector_ImFontPtr_reserve +ImVector_ImFontPtr.resize = lib.ImVector_ImFontPtr_resize +ImVector_ImFontPtr.resizeT = lib.ImVector_ImFontPtr_resizeT +ImVector_ImFontPtr.size = lib.ImVector_ImFontPtr_size +ImVector_ImFontPtr.size_in_bytes = lib.ImVector_ImFontPtr_size_in_bytes +ImVector_ImFontPtr.swap = lib.ImVector_ImFontPtr_swap +M.ImVector_ImFontPtr = ffi.metatype("ImVector_ImFontPtr",ImVector_ImFontPtr) +--------------------------ImGuiTextBuffer---------------------------- +local ImGuiTextBuffer= {} +ImGuiTextBuffer.__index = ImGuiTextBuffer +function ImGuiTextBuffer.__new(ctype) + local ptr = lib.ImGuiTextBuffer_ImGuiTextBuffer() + return ffi.gc(ptr,lib.ImGuiTextBuffer_destroy) +end +function ImGuiTextBuffer:append(str,str_end) + str_end = str_end or nil + return lib.ImGuiTextBuffer_append(self,str,str_end) +end +ImGuiTextBuffer.appendf = lib.ImGuiTextBuffer_appendf +ImGuiTextBuffer.appendfv = lib.ImGuiTextBuffer_appendfv +ImGuiTextBuffer.begin = lib.ImGuiTextBuffer_begin +ImGuiTextBuffer.c_str = lib.ImGuiTextBuffer_c_str +ImGuiTextBuffer.clear = lib.ImGuiTextBuffer_clear +ImGuiTextBuffer.empty = lib.ImGuiTextBuffer_empty +ImGuiTextBuffer._end = lib.ImGuiTextBuffer_end +ImGuiTextBuffer.reserve = lib.ImGuiTextBuffer_reserve +ImGuiTextBuffer.size = lib.ImGuiTextBuffer_size +M.ImGuiTextBuffer = ffi.metatype("ImGuiTextBuffer",ImGuiTextBuffer) +--------------------------ImGuiStyle---------------------------- +local ImGuiStyle= {} +ImGuiStyle.__index = ImGuiStyle +function ImGuiStyle.__new(ctype) + local ptr = lib.ImGuiStyle_ImGuiStyle() + return ffi.gc(ptr,lib.ImGuiStyle_destroy) +end +ImGuiStyle.ScaleAllSizes = lib.ImGuiStyle_ScaleAllSizes +M.ImGuiStyle = ffi.metatype("ImGuiStyle",ImGuiStyle) +--------------------------ImDrawData---------------------------- +local ImDrawData= {} +ImDrawData.__index = ImDrawData +ImDrawData.Clear = lib.ImDrawData_Clear +ImDrawData.DeIndexAllBuffers = lib.ImDrawData_DeIndexAllBuffers +function ImDrawData.__new(ctype) + local ptr = lib.ImDrawData_ImDrawData() + return ffi.gc(ptr,lib.ImDrawData_destroy) +end +ImDrawData.ScaleClipRects = lib.ImDrawData_ScaleClipRects +M.ImDrawData = ffi.metatype("ImDrawData",ImDrawData) +--------------------------ImVector_ImVec2---------------------------- +local ImVector_ImVec2= {} +ImVector_ImVec2.__index = ImVector_ImVec2 +function ImVector_ImVec2.__new(ctype) + local ptr = lib.ImVector_ImVec2_ImVector_ImVec2() + return ffi.gc(ptr,lib.ImVector_ImVec2_destroy) +end +function ImVector_ImVec2.ImVector_ImVec2Vector(src) + local ptr = lib.ImVector_ImVec2_ImVector_ImVec2Vector(src) + return ffi.gc(ptr,lib.ImVector_ImVec2_destroy) +end +ImVector_ImVec2._grow_capacity = lib.ImVector_ImVec2__grow_capacity +ImVector_ImVec2.back = lib.ImVector_ImVec2_back +ImVector_ImVec2.back_const = lib.ImVector_ImVec2_back_const +ImVector_ImVec2.begin = lib.ImVector_ImVec2_begin +ImVector_ImVec2.begin_const = lib.ImVector_ImVec2_begin_const +ImVector_ImVec2.capacity = lib.ImVector_ImVec2_capacity +ImVector_ImVec2.clear = lib.ImVector_ImVec2_clear +ImVector_ImVec2.empty = lib.ImVector_ImVec2_empty +ImVector_ImVec2._end = lib.ImVector_ImVec2_end +ImVector_ImVec2.end_const = lib.ImVector_ImVec2_end_const +ImVector_ImVec2.erase = lib.ImVector_ImVec2_erase +ImVector_ImVec2.eraseTPtr = lib.ImVector_ImVec2_eraseTPtr +ImVector_ImVec2.erase_unsorted = lib.ImVector_ImVec2_erase_unsorted +ImVector_ImVec2.front = lib.ImVector_ImVec2_front +ImVector_ImVec2.front_const = lib.ImVector_ImVec2_front_const +ImVector_ImVec2.index_from_ptr = lib.ImVector_ImVec2_index_from_ptr +ImVector_ImVec2.insert = lib.ImVector_ImVec2_insert +ImVector_ImVec2.pop_back = lib.ImVector_ImVec2_pop_back +ImVector_ImVec2.push_back = lib.ImVector_ImVec2_push_back +ImVector_ImVec2.push_front = lib.ImVector_ImVec2_push_front +ImVector_ImVec2.reserve = lib.ImVector_ImVec2_reserve +ImVector_ImVec2.resize = lib.ImVector_ImVec2_resize +ImVector_ImVec2.resizeT = lib.ImVector_ImVec2_resizeT +ImVector_ImVec2.size = lib.ImVector_ImVec2_size +ImVector_ImVec2.size_in_bytes = lib.ImVector_ImVec2_size_in_bytes +ImVector_ImVec2.swap = lib.ImVector_ImVec2_swap +M.ImVector_ImVec2 = ffi.metatype("ImVector_ImVec2",ImVector_ImVec2) +--------------------------ImVector_ImFontAtlasCustomRect---------------------------- +local ImVector_ImFontAtlasCustomRect= {} +ImVector_ImFontAtlasCustomRect.__index = ImVector_ImFontAtlasCustomRect +function ImVector_ImFontAtlasCustomRect.__new(ctype) + local ptr = lib.ImVector_ImFontAtlasCustomRect_ImVector_ImFontAtlasCustomRect() + return ffi.gc(ptr,lib.ImVector_ImFontAtlasCustomRect_destroy) +end +function ImVector_ImFontAtlasCustomRect.ImVector_ImFontAtlasCustomRectVector(src) + local ptr = lib.ImVector_ImFontAtlasCustomRect_ImVector_ImFontAtlasCustomRectVector(src) + return ffi.gc(ptr,lib.ImVector_ImFontAtlasCustomRect_destroy) +end +ImVector_ImFontAtlasCustomRect._grow_capacity = lib.ImVector_ImFontAtlasCustomRect__grow_capacity +ImVector_ImFontAtlasCustomRect.back = lib.ImVector_ImFontAtlasCustomRect_back +ImVector_ImFontAtlasCustomRect.back_const = lib.ImVector_ImFontAtlasCustomRect_back_const +ImVector_ImFontAtlasCustomRect.begin = lib.ImVector_ImFontAtlasCustomRect_begin +ImVector_ImFontAtlasCustomRect.begin_const = lib.ImVector_ImFontAtlasCustomRect_begin_const +ImVector_ImFontAtlasCustomRect.capacity = lib.ImVector_ImFontAtlasCustomRect_capacity +ImVector_ImFontAtlasCustomRect.clear = lib.ImVector_ImFontAtlasCustomRect_clear +ImVector_ImFontAtlasCustomRect.empty = lib.ImVector_ImFontAtlasCustomRect_empty +ImVector_ImFontAtlasCustomRect._end = lib.ImVector_ImFontAtlasCustomRect_end +ImVector_ImFontAtlasCustomRect.end_const = lib.ImVector_ImFontAtlasCustomRect_end_const +ImVector_ImFontAtlasCustomRect.erase = lib.ImVector_ImFontAtlasCustomRect_erase +ImVector_ImFontAtlasCustomRect.eraseTPtr = lib.ImVector_ImFontAtlasCustomRect_eraseTPtr +ImVector_ImFontAtlasCustomRect.erase_unsorted = lib.ImVector_ImFontAtlasCustomRect_erase_unsorted +ImVector_ImFontAtlasCustomRect.front = lib.ImVector_ImFontAtlasCustomRect_front +ImVector_ImFontAtlasCustomRect.front_const = lib.ImVector_ImFontAtlasCustomRect_front_const +ImVector_ImFontAtlasCustomRect.index_from_ptr = lib.ImVector_ImFontAtlasCustomRect_index_from_ptr +ImVector_ImFontAtlasCustomRect.insert = lib.ImVector_ImFontAtlasCustomRect_insert +ImVector_ImFontAtlasCustomRect.pop_back = lib.ImVector_ImFontAtlasCustomRect_pop_back +ImVector_ImFontAtlasCustomRect.push_back = lib.ImVector_ImFontAtlasCustomRect_push_back +ImVector_ImFontAtlasCustomRect.push_front = lib.ImVector_ImFontAtlasCustomRect_push_front +ImVector_ImFontAtlasCustomRect.reserve = lib.ImVector_ImFontAtlasCustomRect_reserve +ImVector_ImFontAtlasCustomRect.resize = lib.ImVector_ImFontAtlasCustomRect_resize +ImVector_ImFontAtlasCustomRect.resizeT = lib.ImVector_ImFontAtlasCustomRect_resizeT +ImVector_ImFontAtlasCustomRect.size = lib.ImVector_ImFontAtlasCustomRect_size +ImVector_ImFontAtlasCustomRect.size_in_bytes = lib.ImVector_ImFontAtlasCustomRect_size_in_bytes +ImVector_ImFontAtlasCustomRect.swap = lib.ImVector_ImFontAtlasCustomRect_swap +M.ImVector_ImFontAtlasCustomRect = ffi.metatype("ImVector_ImFontAtlasCustomRect",ImVector_ImFontAtlasCustomRect) +--------------------------ImColor---------------------------- +local ImColor= {} +ImColor.__index = ImColor +function ImColor:HSV(h,s,v,a) + a = a or 1.0 + local nonUDT_out = ffi.new("ImColor") + lib.ImColor_HSV_nonUDT(nonUDT_out,self,h,s,v,a) + return nonUDT_out +end +function ImColor:HSV_nonUDT2(h,s,v,a) + a = a or 1.0 + return lib.ImColor_HSV_nonUDT2(self,h,s,v,a) +end +function ImColor.__new(ctype) + local ptr = lib.ImColor_ImColor() + return ffi.gc(ptr,lib.ImColor_destroy) +end +function ImColor.ImColorInt(r,g,b,a) + if a == nil then a = 255 end + local ptr = lib.ImColor_ImColorInt(r,g,b,a) + return ffi.gc(ptr,lib.ImColor_destroy) +end +function ImColor.ImColorU32(rgba) + local ptr = lib.ImColor_ImColorU32(rgba) + return ffi.gc(ptr,lib.ImColor_destroy) +end +function ImColor.ImColorFloat(r,g,b,a) + if a == nil then a = 1.0 end + local ptr = lib.ImColor_ImColorFloat(r,g,b,a) + return ffi.gc(ptr,lib.ImColor_destroy) +end +function ImColor.ImColorVec4(col) + local ptr = lib.ImColor_ImColorVec4(col) + return ffi.gc(ptr,lib.ImColor_destroy) +end +function ImColor:SetHSV(h,s,v,a) + a = a or 1.0 + return lib.ImColor_SetHSV(self,h,s,v,a) +end +M.ImColor = ffi.metatype("ImColor",ImColor) +--------------------------ImVector_ImDrawChannel---------------------------- +local ImVector_ImDrawChannel= {} +ImVector_ImDrawChannel.__index = ImVector_ImDrawChannel +function ImVector_ImDrawChannel.__new(ctype) + local ptr = lib.ImVector_ImDrawChannel_ImVector_ImDrawChannel() + return ffi.gc(ptr,lib.ImVector_ImDrawChannel_destroy) +end +function ImVector_ImDrawChannel.ImVector_ImDrawChannelVector(src) + local ptr = lib.ImVector_ImDrawChannel_ImVector_ImDrawChannelVector(src) + return ffi.gc(ptr,lib.ImVector_ImDrawChannel_destroy) +end +ImVector_ImDrawChannel._grow_capacity = lib.ImVector_ImDrawChannel__grow_capacity +ImVector_ImDrawChannel.back = lib.ImVector_ImDrawChannel_back +ImVector_ImDrawChannel.back_const = lib.ImVector_ImDrawChannel_back_const +ImVector_ImDrawChannel.begin = lib.ImVector_ImDrawChannel_begin +ImVector_ImDrawChannel.begin_const = lib.ImVector_ImDrawChannel_begin_const +ImVector_ImDrawChannel.capacity = lib.ImVector_ImDrawChannel_capacity +ImVector_ImDrawChannel.clear = lib.ImVector_ImDrawChannel_clear +ImVector_ImDrawChannel.empty = lib.ImVector_ImDrawChannel_empty +ImVector_ImDrawChannel._end = lib.ImVector_ImDrawChannel_end +ImVector_ImDrawChannel.end_const = lib.ImVector_ImDrawChannel_end_const +ImVector_ImDrawChannel.erase = lib.ImVector_ImDrawChannel_erase +ImVector_ImDrawChannel.eraseTPtr = lib.ImVector_ImDrawChannel_eraseTPtr +ImVector_ImDrawChannel.erase_unsorted = lib.ImVector_ImDrawChannel_erase_unsorted +ImVector_ImDrawChannel.front = lib.ImVector_ImDrawChannel_front +ImVector_ImDrawChannel.front_const = lib.ImVector_ImDrawChannel_front_const +ImVector_ImDrawChannel.index_from_ptr = lib.ImVector_ImDrawChannel_index_from_ptr +ImVector_ImDrawChannel.insert = lib.ImVector_ImDrawChannel_insert +ImVector_ImDrawChannel.pop_back = lib.ImVector_ImDrawChannel_pop_back +ImVector_ImDrawChannel.push_back = lib.ImVector_ImDrawChannel_push_back +ImVector_ImDrawChannel.push_front = lib.ImVector_ImDrawChannel_push_front +ImVector_ImDrawChannel.reserve = lib.ImVector_ImDrawChannel_reserve +ImVector_ImDrawChannel.resize = lib.ImVector_ImDrawChannel_resize +ImVector_ImDrawChannel.resizeT = lib.ImVector_ImDrawChannel_resizeT +ImVector_ImDrawChannel.size = lib.ImVector_ImDrawChannel_size +ImVector_ImDrawChannel.size_in_bytes = lib.ImVector_ImDrawChannel_size_in_bytes +ImVector_ImDrawChannel.swap = lib.ImVector_ImDrawChannel_swap +M.ImVector_ImDrawChannel = ffi.metatype("ImVector_ImDrawChannel",ImVector_ImDrawChannel) +--------------------------ImDrawList---------------------------- +local ImDrawList= {} +ImDrawList.__index = ImDrawList +function ImDrawList:AddBezierCurve(pos0,cp0,cp1,pos1,col,thickness,num_segments) + num_segments = num_segments or 0 + return lib.ImDrawList_AddBezierCurve(self,pos0,cp0,cp1,pos1,col,thickness,num_segments) +end +ImDrawList.AddCallback = lib.ImDrawList_AddCallback +function ImDrawList:AddCircle(centre,radius,col,num_segments,thickness) + num_segments = num_segments or 12 + thickness = thickness or 1.0 + return lib.ImDrawList_AddCircle(self,centre,radius,col,num_segments,thickness) +end +function ImDrawList:AddCircleFilled(centre,radius,col,num_segments) + num_segments = num_segments or 12 + return lib.ImDrawList_AddCircleFilled(self,centre,radius,col,num_segments) +end +ImDrawList.AddConvexPolyFilled = lib.ImDrawList_AddConvexPolyFilled +ImDrawList.AddDrawCmd = lib.ImDrawList_AddDrawCmd +function ImDrawList:AddImage(user_texture_id,a,b,uv_a,uv_b,col) + uv_b = uv_b or ImVec2(1,1) + uv_a = uv_a or ImVec2(0,0) + col = col or 4294967295 + return lib.ImDrawList_AddImage(self,user_texture_id,a,b,uv_a,uv_b,col) +end +function ImDrawList:AddImageQuad(user_texture_id,a,b,c,d,uv_a,uv_b,uv_c,uv_d,col) + uv_c = uv_c or ImVec2(1,1) + uv_a = uv_a or ImVec2(0,0) + col = col or 4294967295 + uv_b = uv_b or ImVec2(1,0) + uv_d = uv_d or ImVec2(0,1) + return lib.ImDrawList_AddImageQuad(self,user_texture_id,a,b,c,d,uv_a,uv_b,uv_c,uv_d,col) +end +function ImDrawList:AddImageRounded(user_texture_id,a,b,uv_a,uv_b,col,rounding,rounding_corners) + rounding_corners = rounding_corners or lib.ImDrawCornerFlags_All + return lib.ImDrawList_AddImageRounded(self,user_texture_id,a,b,uv_a,uv_b,col,rounding,rounding_corners) +end +function ImDrawList:AddLine(a,b,col,thickness) + thickness = thickness or 1.0 + return lib.ImDrawList_AddLine(self,a,b,col,thickness) +end +ImDrawList.AddPolyline = lib.ImDrawList_AddPolyline +function ImDrawList:AddQuad(a,b,c,d,col,thickness) + thickness = thickness or 1.0 + return lib.ImDrawList_AddQuad(self,a,b,c,d,col,thickness) +end +ImDrawList.AddQuadFilled = lib.ImDrawList_AddQuadFilled +function ImDrawList:AddRect(a,b,col,rounding,rounding_corners,thickness) + rounding = rounding or 0.0 + thickness = thickness or 1.0 + rounding_corners = rounding_corners or lib.ImDrawCornerFlags_All + return lib.ImDrawList_AddRect(self,a,b,col,rounding,rounding_corners,thickness) +end +function ImDrawList:AddRectFilled(a,b,col,rounding,rounding_corners) + rounding = rounding or 0.0 + rounding_corners = rounding_corners or lib.ImDrawCornerFlags_All + return lib.ImDrawList_AddRectFilled(self,a,b,col,rounding,rounding_corners) +end +ImDrawList.AddRectFilledMultiColor = lib.ImDrawList_AddRectFilledMultiColor +function ImDrawList:AddText(pos,col,text_begin,text_end) + text_end = text_end or nil + return lib.ImDrawList_AddText(self,pos,col,text_begin,text_end) +end +function ImDrawList:AddTextFontPtr(font,font_size,pos,col,text_begin,text_end,wrap_width,cpu_fine_clip_rect) + text_end = text_end or nil + cpu_fine_clip_rect = cpu_fine_clip_rect or nil + wrap_width = wrap_width or 0.0 + return lib.ImDrawList_AddTextFontPtr(self,font,font_size,pos,col,text_begin,text_end,wrap_width,cpu_fine_clip_rect) +end +function ImDrawList:AddTriangle(a,b,c,col,thickness) + thickness = thickness or 1.0 + return lib.ImDrawList_AddTriangle(self,a,b,c,col,thickness) +end +ImDrawList.AddTriangleFilled = lib.ImDrawList_AddTriangleFilled +ImDrawList.ChannelsMerge = lib.ImDrawList_ChannelsMerge +ImDrawList.ChannelsSetCurrent = lib.ImDrawList_ChannelsSetCurrent +ImDrawList.ChannelsSplit = lib.ImDrawList_ChannelsSplit +ImDrawList.Clear = lib.ImDrawList_Clear +ImDrawList.ClearFreeMemory = lib.ImDrawList_ClearFreeMemory +ImDrawList.CloneOutput = lib.ImDrawList_CloneOutput +function ImDrawList:GetClipRectMax() + local nonUDT_out = ffi.new("ImVec2") + lib.ImDrawList_GetClipRectMax_nonUDT(nonUDT_out,self) + return nonUDT_out +end +ImDrawList.GetClipRectMax_nonUDT2 = lib.ImDrawList_GetClipRectMax_nonUDT2 +function ImDrawList:GetClipRectMin() + local nonUDT_out = ffi.new("ImVec2") + lib.ImDrawList_GetClipRectMin_nonUDT(nonUDT_out,self) + return nonUDT_out +end +ImDrawList.GetClipRectMin_nonUDT2 = lib.ImDrawList_GetClipRectMin_nonUDT2 +function ImDrawList.__new(ctype,shared_data) + local ptr = lib.ImDrawList_ImDrawList(shared_data) + return ffi.gc(ptr,lib.ImDrawList_destroy) +end +function ImDrawList:PathArcTo(centre,radius,a_min,a_max,num_segments) + num_segments = num_segments or 10 + return lib.ImDrawList_PathArcTo(self,centre,radius,a_min,a_max,num_segments) +end +ImDrawList.PathArcToFast = lib.ImDrawList_PathArcToFast +function ImDrawList:PathBezierCurveTo(p1,p2,p3,num_segments) + num_segments = num_segments or 0 + return lib.ImDrawList_PathBezierCurveTo(self,p1,p2,p3,num_segments) +end +ImDrawList.PathClear = lib.ImDrawList_PathClear +ImDrawList.PathFillConvex = lib.ImDrawList_PathFillConvex +ImDrawList.PathLineTo = lib.ImDrawList_PathLineTo +ImDrawList.PathLineToMergeDuplicate = lib.ImDrawList_PathLineToMergeDuplicate +function ImDrawList:PathRect(rect_min,rect_max,rounding,rounding_corners) + rounding = rounding or 0.0 + rounding_corners = rounding_corners or lib.ImDrawCornerFlags_All + return lib.ImDrawList_PathRect(self,rect_min,rect_max,rounding,rounding_corners) +end +function ImDrawList:PathStroke(col,closed,thickness) + thickness = thickness or 1.0 + return lib.ImDrawList_PathStroke(self,col,closed,thickness) +end +ImDrawList.PopClipRect = lib.ImDrawList_PopClipRect +ImDrawList.PopTextureID = lib.ImDrawList_PopTextureID +ImDrawList.PrimQuadUV = lib.ImDrawList_PrimQuadUV +ImDrawList.PrimRect = lib.ImDrawList_PrimRect +ImDrawList.PrimRectUV = lib.ImDrawList_PrimRectUV +ImDrawList.PrimReserve = lib.ImDrawList_PrimReserve +ImDrawList.PrimVtx = lib.ImDrawList_PrimVtx +ImDrawList.PrimWriteIdx = lib.ImDrawList_PrimWriteIdx +ImDrawList.PrimWriteVtx = lib.ImDrawList_PrimWriteVtx +function ImDrawList:PushClipRect(clip_rect_min,clip_rect_max,intersect_with_current_clip_rect) + intersect_with_current_clip_rect = intersect_with_current_clip_rect or false + return lib.ImDrawList_PushClipRect(self,clip_rect_min,clip_rect_max,intersect_with_current_clip_rect) +end +ImDrawList.PushClipRectFullScreen = lib.ImDrawList_PushClipRectFullScreen +ImDrawList.PushTextureID = lib.ImDrawList_PushTextureID +ImDrawList.UpdateClipRect = lib.ImDrawList_UpdateClipRect +ImDrawList.UpdateTextureID = lib.ImDrawList_UpdateTextureID +M.ImDrawList = ffi.metatype("ImDrawList",ImDrawList) +--------------------------ImGuiTextRange---------------------------- +local ImGuiTextRange= {} +ImGuiTextRange.__index = ImGuiTextRange +function ImGuiTextRange.__new(ctype) + local ptr = lib.ImGuiTextRange_ImGuiTextRange() + return ffi.gc(ptr,lib.ImGuiTextRange_destroy) +end +function ImGuiTextRange.ImGuiTextRangeStr(_b,_e) + local ptr = lib.ImGuiTextRange_ImGuiTextRangeStr(_b,_e) + return ffi.gc(ptr,lib.ImGuiTextRange_destroy) +end +ImGuiTextRange.empty = lib.ImGuiTextRange_empty +ImGuiTextRange.split = lib.ImGuiTextRange_split +M.ImGuiTextRange = ffi.metatype("ImGuiTextRange",ImGuiTextRange) +--------------------------ImVector_ImFontConfig---------------------------- +local ImVector_ImFontConfig= {} +ImVector_ImFontConfig.__index = ImVector_ImFontConfig +function ImVector_ImFontConfig.__new(ctype) + local ptr = lib.ImVector_ImFontConfig_ImVector_ImFontConfig() + return ffi.gc(ptr,lib.ImVector_ImFontConfig_destroy) +end +function ImVector_ImFontConfig.ImVector_ImFontConfigVector(src) + local ptr = lib.ImVector_ImFontConfig_ImVector_ImFontConfigVector(src) + return ffi.gc(ptr,lib.ImVector_ImFontConfig_destroy) +end +ImVector_ImFontConfig._grow_capacity = lib.ImVector_ImFontConfig__grow_capacity +ImVector_ImFontConfig.back = lib.ImVector_ImFontConfig_back +ImVector_ImFontConfig.back_const = lib.ImVector_ImFontConfig_back_const +ImVector_ImFontConfig.begin = lib.ImVector_ImFontConfig_begin +ImVector_ImFontConfig.begin_const = lib.ImVector_ImFontConfig_begin_const +ImVector_ImFontConfig.capacity = lib.ImVector_ImFontConfig_capacity +ImVector_ImFontConfig.clear = lib.ImVector_ImFontConfig_clear +ImVector_ImFontConfig.empty = lib.ImVector_ImFontConfig_empty +ImVector_ImFontConfig._end = lib.ImVector_ImFontConfig_end +ImVector_ImFontConfig.end_const = lib.ImVector_ImFontConfig_end_const +ImVector_ImFontConfig.erase = lib.ImVector_ImFontConfig_erase +ImVector_ImFontConfig.eraseTPtr = lib.ImVector_ImFontConfig_eraseTPtr +ImVector_ImFontConfig.erase_unsorted = lib.ImVector_ImFontConfig_erase_unsorted +ImVector_ImFontConfig.front = lib.ImVector_ImFontConfig_front +ImVector_ImFontConfig.front_const = lib.ImVector_ImFontConfig_front_const +ImVector_ImFontConfig.index_from_ptr = lib.ImVector_ImFontConfig_index_from_ptr +ImVector_ImFontConfig.insert = lib.ImVector_ImFontConfig_insert +ImVector_ImFontConfig.pop_back = lib.ImVector_ImFontConfig_pop_back +ImVector_ImFontConfig.push_back = lib.ImVector_ImFontConfig_push_back +ImVector_ImFontConfig.push_front = lib.ImVector_ImFontConfig_push_front +ImVector_ImFontConfig.reserve = lib.ImVector_ImFontConfig_reserve +ImVector_ImFontConfig.resize = lib.ImVector_ImFontConfig_resize +ImVector_ImFontConfig.resizeT = lib.ImVector_ImFontConfig_resizeT +ImVector_ImFontConfig.size = lib.ImVector_ImFontConfig_size +ImVector_ImFontConfig.size_in_bytes = lib.ImVector_ImFontConfig_size_in_bytes +ImVector_ImFontConfig.swap = lib.ImVector_ImFontConfig_swap +M.ImVector_ImFontConfig = ffi.metatype("ImVector_ImFontConfig",ImVector_ImFontConfig) +--------------------------ImVector_ImU32---------------------------- +local ImVector_ImU32= {} +ImVector_ImU32.__index = ImVector_ImU32 +function ImVector_ImU32.__new(ctype) + local ptr = lib.ImVector_ImU32_ImVector_ImU32() + return ffi.gc(ptr,lib.ImVector_ImU32_destroy) +end +function ImVector_ImU32.ImVector_ImU32Vector(src) + local ptr = lib.ImVector_ImU32_ImVector_ImU32Vector(src) + return ffi.gc(ptr,lib.ImVector_ImU32_destroy) +end +ImVector_ImU32._grow_capacity = lib.ImVector_ImU32__grow_capacity +ImVector_ImU32.back = lib.ImVector_ImU32_back +ImVector_ImU32.back_const = lib.ImVector_ImU32_back_const +ImVector_ImU32.begin = lib.ImVector_ImU32_begin +ImVector_ImU32.begin_const = lib.ImVector_ImU32_begin_const +ImVector_ImU32.capacity = lib.ImVector_ImU32_capacity +ImVector_ImU32.clear = lib.ImVector_ImU32_clear +ImVector_ImU32.empty = lib.ImVector_ImU32_empty +ImVector_ImU32._end = lib.ImVector_ImU32_end +ImVector_ImU32.end_const = lib.ImVector_ImU32_end_const +ImVector_ImU32.erase = lib.ImVector_ImU32_erase +ImVector_ImU32.eraseTPtr = lib.ImVector_ImU32_eraseTPtr +ImVector_ImU32.erase_unsorted = lib.ImVector_ImU32_erase_unsorted +ImVector_ImU32.front = lib.ImVector_ImU32_front +ImVector_ImU32.front_const = lib.ImVector_ImU32_front_const +ImVector_ImU32.index_from_ptr = lib.ImVector_ImU32_index_from_ptr +ImVector_ImU32.insert = lib.ImVector_ImU32_insert +ImVector_ImU32.pop_back = lib.ImVector_ImU32_pop_back +ImVector_ImU32.push_back = lib.ImVector_ImU32_push_back +ImVector_ImU32.push_front = lib.ImVector_ImU32_push_front +ImVector_ImU32.reserve = lib.ImVector_ImU32_reserve +ImVector_ImU32.resize = lib.ImVector_ImU32_resize +ImVector_ImU32.resizeT = lib.ImVector_ImU32_resizeT +ImVector_ImU32.size = lib.ImVector_ImU32_size +ImVector_ImU32.size_in_bytes = lib.ImVector_ImU32_size_in_bytes +ImVector_ImU32.swap = lib.ImVector_ImU32_swap +M.ImVector_ImU32 = ffi.metatype("ImVector_ImU32",ImVector_ImU32) +--------------------------ImGuiListClipper---------------------------- +local ImGuiListClipper= {} +ImGuiListClipper.__index = ImGuiListClipper +function ImGuiListClipper:Begin(items_count,items_height) + items_height = items_height or -1.0 + return lib.ImGuiListClipper_Begin(self,items_count,items_height) +end +ImGuiListClipper.End = lib.ImGuiListClipper_End +function ImGuiListClipper.__new(ctype,items_count,items_height) + if items_height == nil then items_height = -1.0 end + if items_count == nil then items_count = -1 end + local ptr = lib.ImGuiListClipper_ImGuiListClipper(items_count,items_height) + return ffi.gc(ptr,lib.ImGuiListClipper_destroy) +end +ImGuiListClipper.Step = lib.ImGuiListClipper_Step +M.ImGuiListClipper = ffi.metatype("ImGuiListClipper",ImGuiListClipper) +--------------------------ImGuiIO---------------------------- +local ImGuiIO= {} +ImGuiIO.__index = ImGuiIO +ImGuiIO.AddInputCharacter = lib.ImGuiIO_AddInputCharacter +ImGuiIO.AddInputCharactersUTF8 = lib.ImGuiIO_AddInputCharactersUTF8 +ImGuiIO.ClearInputCharacters = lib.ImGuiIO_ClearInputCharacters +function ImGuiIO.__new(ctype) + local ptr = lib.ImGuiIO_ImGuiIO() + return ffi.gc(ptr,lib.ImGuiIO_destroy) +end +M.ImGuiIO = ffi.metatype("ImGuiIO",ImGuiIO) +--------------------------ImVector_ImTextureID---------------------------- +local ImVector_ImTextureID= {} +ImVector_ImTextureID.__index = ImVector_ImTextureID +function ImVector_ImTextureID.__new(ctype) + local ptr = lib.ImVector_ImTextureID_ImVector_ImTextureID() + return ffi.gc(ptr,lib.ImVector_ImTextureID_destroy) +end +function ImVector_ImTextureID.ImVector_ImTextureIDVector(src) + local ptr = lib.ImVector_ImTextureID_ImVector_ImTextureIDVector(src) + return ffi.gc(ptr,lib.ImVector_ImTextureID_destroy) +end +ImVector_ImTextureID._grow_capacity = lib.ImVector_ImTextureID__grow_capacity +ImVector_ImTextureID.back = lib.ImVector_ImTextureID_back +ImVector_ImTextureID.back_const = lib.ImVector_ImTextureID_back_const +ImVector_ImTextureID.begin = lib.ImVector_ImTextureID_begin +ImVector_ImTextureID.begin_const = lib.ImVector_ImTextureID_begin_const +ImVector_ImTextureID.capacity = lib.ImVector_ImTextureID_capacity +ImVector_ImTextureID.clear = lib.ImVector_ImTextureID_clear +ImVector_ImTextureID.empty = lib.ImVector_ImTextureID_empty +ImVector_ImTextureID._end = lib.ImVector_ImTextureID_end +ImVector_ImTextureID.end_const = lib.ImVector_ImTextureID_end_const +ImVector_ImTextureID.erase = lib.ImVector_ImTextureID_erase +ImVector_ImTextureID.eraseTPtr = lib.ImVector_ImTextureID_eraseTPtr +ImVector_ImTextureID.erase_unsorted = lib.ImVector_ImTextureID_erase_unsorted +ImVector_ImTextureID.front = lib.ImVector_ImTextureID_front +ImVector_ImTextureID.front_const = lib.ImVector_ImTextureID_front_const +ImVector_ImTextureID.index_from_ptr = lib.ImVector_ImTextureID_index_from_ptr +ImVector_ImTextureID.insert = lib.ImVector_ImTextureID_insert +ImVector_ImTextureID.pop_back = lib.ImVector_ImTextureID_pop_back +ImVector_ImTextureID.push_back = lib.ImVector_ImTextureID_push_back +ImVector_ImTextureID.push_front = lib.ImVector_ImTextureID_push_front +ImVector_ImTextureID.reserve = lib.ImVector_ImTextureID_reserve +ImVector_ImTextureID.resize = lib.ImVector_ImTextureID_resize +ImVector_ImTextureID.resizeT = lib.ImVector_ImTextureID_resizeT +ImVector_ImTextureID.size = lib.ImVector_ImTextureID_size +ImVector_ImTextureID.size_in_bytes = lib.ImVector_ImTextureID_size_in_bytes +ImVector_ImTextureID.swap = lib.ImVector_ImTextureID_swap +M.ImVector_ImTextureID = ffi.metatype("ImVector_ImTextureID",ImVector_ImTextureID) +--------------------------ImVector_ImDrawCmd---------------------------- +local ImVector_ImDrawCmd= {} +ImVector_ImDrawCmd.__index = ImVector_ImDrawCmd +function ImVector_ImDrawCmd.__new(ctype) + local ptr = lib.ImVector_ImDrawCmd_ImVector_ImDrawCmd() + return ffi.gc(ptr,lib.ImVector_ImDrawCmd_destroy) +end +function ImVector_ImDrawCmd.ImVector_ImDrawCmdVector(src) + local ptr = lib.ImVector_ImDrawCmd_ImVector_ImDrawCmdVector(src) + return ffi.gc(ptr,lib.ImVector_ImDrawCmd_destroy) +end +ImVector_ImDrawCmd._grow_capacity = lib.ImVector_ImDrawCmd__grow_capacity +ImVector_ImDrawCmd.back = lib.ImVector_ImDrawCmd_back +ImVector_ImDrawCmd.back_const = lib.ImVector_ImDrawCmd_back_const +ImVector_ImDrawCmd.begin = lib.ImVector_ImDrawCmd_begin +ImVector_ImDrawCmd.begin_const = lib.ImVector_ImDrawCmd_begin_const +ImVector_ImDrawCmd.capacity = lib.ImVector_ImDrawCmd_capacity +ImVector_ImDrawCmd.clear = lib.ImVector_ImDrawCmd_clear +ImVector_ImDrawCmd.empty = lib.ImVector_ImDrawCmd_empty +ImVector_ImDrawCmd._end = lib.ImVector_ImDrawCmd_end +ImVector_ImDrawCmd.end_const = lib.ImVector_ImDrawCmd_end_const +ImVector_ImDrawCmd.erase = lib.ImVector_ImDrawCmd_erase +ImVector_ImDrawCmd.eraseTPtr = lib.ImVector_ImDrawCmd_eraseTPtr +ImVector_ImDrawCmd.erase_unsorted = lib.ImVector_ImDrawCmd_erase_unsorted +ImVector_ImDrawCmd.front = lib.ImVector_ImDrawCmd_front +ImVector_ImDrawCmd.front_const = lib.ImVector_ImDrawCmd_front_const +ImVector_ImDrawCmd.index_from_ptr = lib.ImVector_ImDrawCmd_index_from_ptr +ImVector_ImDrawCmd.insert = lib.ImVector_ImDrawCmd_insert +ImVector_ImDrawCmd.pop_back = lib.ImVector_ImDrawCmd_pop_back +ImVector_ImDrawCmd.push_back = lib.ImVector_ImDrawCmd_push_back +ImVector_ImDrawCmd.push_front = lib.ImVector_ImDrawCmd_push_front +ImVector_ImDrawCmd.reserve = lib.ImVector_ImDrawCmd_reserve +ImVector_ImDrawCmd.resize = lib.ImVector_ImDrawCmd_resize +ImVector_ImDrawCmd.resizeT = lib.ImVector_ImDrawCmd_resizeT +ImVector_ImDrawCmd.size = lib.ImVector_ImDrawCmd_size +ImVector_ImDrawCmd.size_in_bytes = lib.ImVector_ImDrawCmd_size_in_bytes +ImVector_ImDrawCmd.swap = lib.ImVector_ImDrawCmd_swap +M.ImVector_ImDrawCmd = ffi.metatype("ImVector_ImDrawCmd",ImVector_ImDrawCmd) +--------------------------ImGuiStorage---------------------------- +local ImGuiStorage= {} +ImGuiStorage.__index = ImGuiStorage +ImGuiStorage.BuildSortByKey = lib.ImGuiStorage_BuildSortByKey +ImGuiStorage.Clear = lib.ImGuiStorage_Clear +function ImGuiStorage:GetBool(key,default_val) + default_val = default_val or false + return lib.ImGuiStorage_GetBool(self,key,default_val) +end +function ImGuiStorage:GetBoolRef(key,default_val) + default_val = default_val or false + return lib.ImGuiStorage_GetBoolRef(self,key,default_val) +end +function ImGuiStorage:GetFloat(key,default_val) + default_val = default_val or 0.0 + return lib.ImGuiStorage_GetFloat(self,key,default_val) +end +function ImGuiStorage:GetFloatRef(key,default_val) + default_val = default_val or 0.0 + return lib.ImGuiStorage_GetFloatRef(self,key,default_val) +end +function ImGuiStorage:GetInt(key,default_val) + default_val = default_val or 0 + return lib.ImGuiStorage_GetInt(self,key,default_val) +end +function ImGuiStorage:GetIntRef(key,default_val) + default_val = default_val or 0 + return lib.ImGuiStorage_GetIntRef(self,key,default_val) +end +ImGuiStorage.GetVoidPtr = lib.ImGuiStorage_GetVoidPtr +function ImGuiStorage:GetVoidPtrRef(key,default_val) + default_val = default_val or nil + return lib.ImGuiStorage_GetVoidPtrRef(self,key,default_val) +end +ImGuiStorage.SetAllInt = lib.ImGuiStorage_SetAllInt +ImGuiStorage.SetBool = lib.ImGuiStorage_SetBool +ImGuiStorage.SetFloat = lib.ImGuiStorage_SetFloat +ImGuiStorage.SetInt = lib.ImGuiStorage_SetInt +ImGuiStorage.SetVoidPtr = lib.ImGuiStorage_SetVoidPtr +M.ImGuiStorage = ffi.metatype("ImGuiStorage",ImGuiStorage) +--------------------------ImFontAtlasCustomRect---------------------------- +local ImFontAtlasCustomRect= {} +ImFontAtlasCustomRect.__index = ImFontAtlasCustomRect +function ImFontAtlasCustomRect.__new(ctype) + local ptr = lib.ImFontAtlasCustomRect_ImFontAtlasCustomRect() + return ffi.gc(ptr,lib.ImFontAtlasCustomRect_destroy) +end +ImFontAtlasCustomRect.IsPacked = lib.ImFontAtlasCustomRect_IsPacked +M.ImFontAtlasCustomRect = ffi.metatype("ImFontAtlasCustomRect",ImFontAtlasCustomRect) +--------------------------ImVector_ImWchar---------------------------- +local ImVector_ImWchar= {} +ImVector_ImWchar.__index = ImVector_ImWchar +function ImVector_ImWchar.__new(ctype) + local ptr = lib.ImVector_ImWchar_ImVector_ImWchar() + return ffi.gc(ptr,lib.ImVector_ImWchar_destroy) +end +function ImVector_ImWchar.ImVector_ImWcharVector(src) + local ptr = lib.ImVector_ImWchar_ImVector_ImWcharVector(src) + return ffi.gc(ptr,lib.ImVector_ImWchar_destroy) +end +ImVector_ImWchar._grow_capacity = lib.ImVector_ImWchar__grow_capacity +ImVector_ImWchar.back = lib.ImVector_ImWchar_back +ImVector_ImWchar.back_const = lib.ImVector_ImWchar_back_const +ImVector_ImWchar.begin = lib.ImVector_ImWchar_begin +ImVector_ImWchar.begin_const = lib.ImVector_ImWchar_begin_const +ImVector_ImWchar.capacity = lib.ImVector_ImWchar_capacity +ImVector_ImWchar.clear = lib.ImVector_ImWchar_clear +ImVector_ImWchar.contains = lib.ImVector_ImWchar_contains +ImVector_ImWchar.empty = lib.ImVector_ImWchar_empty +ImVector_ImWchar._end = lib.ImVector_ImWchar_end +ImVector_ImWchar.end_const = lib.ImVector_ImWchar_end_const +ImVector_ImWchar.erase = lib.ImVector_ImWchar_erase +ImVector_ImWchar.eraseTPtr = lib.ImVector_ImWchar_eraseTPtr +ImVector_ImWchar.erase_unsorted = lib.ImVector_ImWchar_erase_unsorted +ImVector_ImWchar.front = lib.ImVector_ImWchar_front +ImVector_ImWchar.front_const = lib.ImVector_ImWchar_front_const +ImVector_ImWchar.index_from_ptr = lib.ImVector_ImWchar_index_from_ptr +ImVector_ImWchar.insert = lib.ImVector_ImWchar_insert +ImVector_ImWchar.pop_back = lib.ImVector_ImWchar_pop_back +ImVector_ImWchar.push_back = lib.ImVector_ImWchar_push_back +ImVector_ImWchar.push_front = lib.ImVector_ImWchar_push_front +ImVector_ImWchar.reserve = lib.ImVector_ImWchar_reserve +ImVector_ImWchar.resize = lib.ImVector_ImWchar_resize +ImVector_ImWchar.resizeT = lib.ImVector_ImWchar_resizeT +ImVector_ImWchar.size = lib.ImVector_ImWchar_size +ImVector_ImWchar.size_in_bytes = lib.ImVector_ImWchar_size_in_bytes +ImVector_ImWchar.swap = lib.ImVector_ImWchar_swap +M.ImVector_ImWchar = ffi.metatype("ImVector_ImWchar",ImVector_ImWchar) +--------------------------ImVector_char---------------------------- +local ImVector_char= {} +ImVector_char.__index = ImVector_char +function ImVector_char.__new(ctype) + local ptr = lib.ImVector_char_ImVector_char() + return ffi.gc(ptr,lib.ImVector_char_destroy) +end +function ImVector_char.ImVector_charVector(src) + local ptr = lib.ImVector_char_ImVector_charVector(src) + return ffi.gc(ptr,lib.ImVector_char_destroy) +end +ImVector_char._grow_capacity = lib.ImVector_char__grow_capacity +ImVector_char.back = lib.ImVector_char_back +ImVector_char.back_const = lib.ImVector_char_back_const +ImVector_char.begin = lib.ImVector_char_begin +ImVector_char.begin_const = lib.ImVector_char_begin_const +ImVector_char.capacity = lib.ImVector_char_capacity +ImVector_char.clear = lib.ImVector_char_clear +ImVector_char.contains = lib.ImVector_char_contains +ImVector_char.empty = lib.ImVector_char_empty +ImVector_char._end = lib.ImVector_char_end +ImVector_char.end_const = lib.ImVector_char_end_const +ImVector_char.erase = lib.ImVector_char_erase +ImVector_char.eraseTPtr = lib.ImVector_char_eraseTPtr +ImVector_char.erase_unsorted = lib.ImVector_char_erase_unsorted +ImVector_char.front = lib.ImVector_char_front +ImVector_char.front_const = lib.ImVector_char_front_const +ImVector_char.index_from_ptr = lib.ImVector_char_index_from_ptr +ImVector_char.insert = lib.ImVector_char_insert +ImVector_char.pop_back = lib.ImVector_char_pop_back +ImVector_char.push_back = lib.ImVector_char_push_back +ImVector_char.push_front = lib.ImVector_char_push_front +ImVector_char.reserve = lib.ImVector_char_reserve +ImVector_char.resize = lib.ImVector_char_resize +ImVector_char.resizeT = lib.ImVector_char_resizeT +ImVector_char.size = lib.ImVector_char_size +ImVector_char.size_in_bytes = lib.ImVector_char_size_in_bytes +ImVector_char.swap = lib.ImVector_char_swap +M.ImVector_char = ffi.metatype("ImVector_char",ImVector_char) +--------------------------ImGuiStoragePair---------------------------- +local ImGuiStoragePair= {} +ImGuiStoragePair.__index = ImGuiStoragePair +function ImGuiStoragePair.ImGuiStoragePairInt(_key,_val_i) + local ptr = lib.ImGuiStoragePair_ImGuiStoragePairInt(_key,_val_i) + return ffi.gc(ptr,lib.ImGuiStoragePair_destroy) +end +function ImGuiStoragePair.ImGuiStoragePairFloat(_key,_val_f) + local ptr = lib.ImGuiStoragePair_ImGuiStoragePairFloat(_key,_val_f) + return ffi.gc(ptr,lib.ImGuiStoragePair_destroy) +end +function ImGuiStoragePair.ImGuiStoragePairPtr(_key,_val_p) + local ptr = lib.ImGuiStoragePair_ImGuiStoragePairPtr(_key,_val_p) + return ffi.gc(ptr,lib.ImGuiStoragePair_destroy) +end +M.ImGuiStoragePair = ffi.metatype("ImGuiStoragePair",ImGuiStoragePair) +--------------------------ImFont---------------------------- +local ImFont= {} +ImFont.__index = ImFont +ImFont.AddGlyph = lib.ImFont_AddGlyph +function ImFont:AddRemapChar(dst,src,overwrite_dst) + if overwrite_dst == nil then overwrite_dst = true end + return lib.ImFont_AddRemapChar(self,dst,src,overwrite_dst) +end +ImFont.BuildLookupTable = lib.ImFont_BuildLookupTable +function ImFont:CalcTextSizeA(size,max_width,wrap_width,text_begin,text_end,remaining) + text_end = text_end or nil + remaining = remaining or nil + local nonUDT_out = ffi.new("ImVec2") + lib.ImFont_CalcTextSizeA_nonUDT(nonUDT_out,self,size,max_width,wrap_width,text_begin,text_end,remaining) + return nonUDT_out +end +function ImFont:CalcTextSizeA_nonUDT2(size,max_width,wrap_width,text_begin,text_end,remaining) + text_end = text_end or nil + remaining = remaining or nil + return lib.ImFont_CalcTextSizeA_nonUDT2(self,size,max_width,wrap_width,text_begin,text_end,remaining) +end +ImFont.CalcWordWrapPositionA = lib.ImFont_CalcWordWrapPositionA +ImFont.ClearOutputData = lib.ImFont_ClearOutputData +ImFont.FindGlyph = lib.ImFont_FindGlyph +ImFont.FindGlyphNoFallback = lib.ImFont_FindGlyphNoFallback +ImFont.GetCharAdvance = lib.ImFont_GetCharAdvance +ImFont.GetDebugName = lib.ImFont_GetDebugName +ImFont.GrowIndex = lib.ImFont_GrowIndex +function ImFont.__new(ctype) + local ptr = lib.ImFont_ImFont() + return ffi.gc(ptr,lib.ImFont_destroy) +end +ImFont.IsLoaded = lib.ImFont_IsLoaded +ImFont.RenderChar = lib.ImFont_RenderChar +function ImFont:RenderText(draw_list,size,pos,col,clip_rect,text_begin,text_end,wrap_width,cpu_fine_clip) + wrap_width = wrap_width or 0.0 + cpu_fine_clip = cpu_fine_clip or false + return lib.ImFont_RenderText(self,draw_list,size,pos,col,clip_rect,text_begin,text_end,wrap_width,cpu_fine_clip) +end +ImFont.SetFallbackChar = lib.ImFont_SetFallbackChar +M.ImFont = ffi.metatype("ImFont",ImFont) +--------------------------ImGuiOnceUponAFrame---------------------------- +local ImGuiOnceUponAFrame= {} +ImGuiOnceUponAFrame.__index = ImGuiOnceUponAFrame +function ImGuiOnceUponAFrame.__new(ctype) + local ptr = lib.ImGuiOnceUponAFrame_ImGuiOnceUponAFrame() + return ffi.gc(ptr,lib.ImGuiOnceUponAFrame_destroy) +end +M.ImGuiOnceUponAFrame = ffi.metatype("ImGuiOnceUponAFrame",ImGuiOnceUponAFrame) +--------------------------ImVector_ImVec4---------------------------- +local ImVector_ImVec4= {} +ImVector_ImVec4.__index = ImVector_ImVec4 +function ImVector_ImVec4.__new(ctype) + local ptr = lib.ImVector_ImVec4_ImVector_ImVec4() + return ffi.gc(ptr,lib.ImVector_ImVec4_destroy) +end +function ImVector_ImVec4.ImVector_ImVec4Vector(src) + local ptr = lib.ImVector_ImVec4_ImVector_ImVec4Vector(src) + return ffi.gc(ptr,lib.ImVector_ImVec4_destroy) +end +ImVector_ImVec4._grow_capacity = lib.ImVector_ImVec4__grow_capacity +ImVector_ImVec4.back = lib.ImVector_ImVec4_back +ImVector_ImVec4.back_const = lib.ImVector_ImVec4_back_const +ImVector_ImVec4.begin = lib.ImVector_ImVec4_begin +ImVector_ImVec4.begin_const = lib.ImVector_ImVec4_begin_const +ImVector_ImVec4.capacity = lib.ImVector_ImVec4_capacity +ImVector_ImVec4.clear = lib.ImVector_ImVec4_clear +ImVector_ImVec4.empty = lib.ImVector_ImVec4_empty +ImVector_ImVec4._end = lib.ImVector_ImVec4_end +ImVector_ImVec4.end_const = lib.ImVector_ImVec4_end_const +ImVector_ImVec4.erase = lib.ImVector_ImVec4_erase +ImVector_ImVec4.eraseTPtr = lib.ImVector_ImVec4_eraseTPtr +ImVector_ImVec4.erase_unsorted = lib.ImVector_ImVec4_erase_unsorted +ImVector_ImVec4.front = lib.ImVector_ImVec4_front +ImVector_ImVec4.front_const = lib.ImVector_ImVec4_front_const +ImVector_ImVec4.index_from_ptr = lib.ImVector_ImVec4_index_from_ptr +ImVector_ImVec4.insert = lib.ImVector_ImVec4_insert +ImVector_ImVec4.pop_back = lib.ImVector_ImVec4_pop_back +ImVector_ImVec4.push_back = lib.ImVector_ImVec4_push_back +ImVector_ImVec4.push_front = lib.ImVector_ImVec4_push_front +ImVector_ImVec4.reserve = lib.ImVector_ImVec4_reserve +ImVector_ImVec4.resize = lib.ImVector_ImVec4_resize +ImVector_ImVec4.resizeT = lib.ImVector_ImVec4_resizeT +ImVector_ImVec4.size = lib.ImVector_ImVec4_size +ImVector_ImVec4.size_in_bytes = lib.ImVector_ImVec4_size_in_bytes +ImVector_ImVec4.swap = lib.ImVector_ImVec4_swap +M.ImVector_ImVec4 = ffi.metatype("ImVector_ImVec4",ImVector_ImVec4) +--------------------------ImVector_ImDrawIdx---------------------------- +local ImVector_ImDrawIdx= {} +ImVector_ImDrawIdx.__index = ImVector_ImDrawIdx +function ImVector_ImDrawIdx.__new(ctype) + local ptr = lib.ImVector_ImDrawIdx_ImVector_ImDrawIdx() + return ffi.gc(ptr,lib.ImVector_ImDrawIdx_destroy) +end +function ImVector_ImDrawIdx.ImVector_ImDrawIdxVector(src) + local ptr = lib.ImVector_ImDrawIdx_ImVector_ImDrawIdxVector(src) + return ffi.gc(ptr,lib.ImVector_ImDrawIdx_destroy) +end +ImVector_ImDrawIdx._grow_capacity = lib.ImVector_ImDrawIdx__grow_capacity +ImVector_ImDrawIdx.back = lib.ImVector_ImDrawIdx_back +ImVector_ImDrawIdx.back_const = lib.ImVector_ImDrawIdx_back_const +ImVector_ImDrawIdx.begin = lib.ImVector_ImDrawIdx_begin +ImVector_ImDrawIdx.begin_const = lib.ImVector_ImDrawIdx_begin_const +ImVector_ImDrawIdx.capacity = lib.ImVector_ImDrawIdx_capacity +ImVector_ImDrawIdx.clear = lib.ImVector_ImDrawIdx_clear +ImVector_ImDrawIdx.empty = lib.ImVector_ImDrawIdx_empty +ImVector_ImDrawIdx._end = lib.ImVector_ImDrawIdx_end +ImVector_ImDrawIdx.end_const = lib.ImVector_ImDrawIdx_end_const +ImVector_ImDrawIdx.erase = lib.ImVector_ImDrawIdx_erase +ImVector_ImDrawIdx.eraseTPtr = lib.ImVector_ImDrawIdx_eraseTPtr +ImVector_ImDrawIdx.erase_unsorted = lib.ImVector_ImDrawIdx_erase_unsorted +ImVector_ImDrawIdx.front = lib.ImVector_ImDrawIdx_front +ImVector_ImDrawIdx.front_const = lib.ImVector_ImDrawIdx_front_const +ImVector_ImDrawIdx.index_from_ptr = lib.ImVector_ImDrawIdx_index_from_ptr +ImVector_ImDrawIdx.insert = lib.ImVector_ImDrawIdx_insert +ImVector_ImDrawIdx.pop_back = lib.ImVector_ImDrawIdx_pop_back +ImVector_ImDrawIdx.push_back = lib.ImVector_ImDrawIdx_push_back +ImVector_ImDrawIdx.push_front = lib.ImVector_ImDrawIdx_push_front +ImVector_ImDrawIdx.reserve = lib.ImVector_ImDrawIdx_reserve +ImVector_ImDrawIdx.resize = lib.ImVector_ImDrawIdx_resize +ImVector_ImDrawIdx.resizeT = lib.ImVector_ImDrawIdx_resizeT +ImVector_ImDrawIdx.size = lib.ImVector_ImDrawIdx_size +ImVector_ImDrawIdx.size_in_bytes = lib.ImVector_ImDrawIdx_size_in_bytes +ImVector_ImDrawIdx.swap = lib.ImVector_ImDrawIdx_swap +M.ImVector_ImDrawIdx = ffi.metatype("ImVector_ImDrawIdx",ImVector_ImDrawIdx) +--------------------------ImVector_ImGuiTextRange---------------------------- +local ImVector_ImGuiTextRange= {} +ImVector_ImGuiTextRange.__index = ImVector_ImGuiTextRange +function ImVector_ImGuiTextRange.__new(ctype) + local ptr = lib.ImVector_ImGuiTextRange_ImVector_ImGuiTextRange() + return ffi.gc(ptr,lib.ImVector_ImGuiTextRange_destroy) +end +function ImVector_ImGuiTextRange.ImVector_ImGuiTextRangeVector(src) + local ptr = lib.ImVector_ImGuiTextRange_ImVector_ImGuiTextRangeVector(src) + return ffi.gc(ptr,lib.ImVector_ImGuiTextRange_destroy) +end +ImVector_ImGuiTextRange._grow_capacity = lib.ImVector_ImGuiTextRange__grow_capacity +ImVector_ImGuiTextRange.back = lib.ImVector_ImGuiTextRange_back +ImVector_ImGuiTextRange.back_const = lib.ImVector_ImGuiTextRange_back_const +ImVector_ImGuiTextRange.begin = lib.ImVector_ImGuiTextRange_begin +ImVector_ImGuiTextRange.begin_const = lib.ImVector_ImGuiTextRange_begin_const +ImVector_ImGuiTextRange.capacity = lib.ImVector_ImGuiTextRange_capacity +ImVector_ImGuiTextRange.clear = lib.ImVector_ImGuiTextRange_clear +ImVector_ImGuiTextRange.empty = lib.ImVector_ImGuiTextRange_empty +ImVector_ImGuiTextRange._end = lib.ImVector_ImGuiTextRange_end +ImVector_ImGuiTextRange.end_const = lib.ImVector_ImGuiTextRange_end_const +ImVector_ImGuiTextRange.erase = lib.ImVector_ImGuiTextRange_erase +ImVector_ImGuiTextRange.eraseTPtr = lib.ImVector_ImGuiTextRange_eraseTPtr +ImVector_ImGuiTextRange.erase_unsorted = lib.ImVector_ImGuiTextRange_erase_unsorted +ImVector_ImGuiTextRange.front = lib.ImVector_ImGuiTextRange_front +ImVector_ImGuiTextRange.front_const = lib.ImVector_ImGuiTextRange_front_const +ImVector_ImGuiTextRange.index_from_ptr = lib.ImVector_ImGuiTextRange_index_from_ptr +ImVector_ImGuiTextRange.insert = lib.ImVector_ImGuiTextRange_insert +ImVector_ImGuiTextRange.pop_back = lib.ImVector_ImGuiTextRange_pop_back +ImVector_ImGuiTextRange.push_back = lib.ImVector_ImGuiTextRange_push_back +ImVector_ImGuiTextRange.push_front = lib.ImVector_ImGuiTextRange_push_front +ImVector_ImGuiTextRange.reserve = lib.ImVector_ImGuiTextRange_reserve +ImVector_ImGuiTextRange.resize = lib.ImVector_ImGuiTextRange_resize +ImVector_ImGuiTextRange.resizeT = lib.ImVector_ImGuiTextRange_resizeT +ImVector_ImGuiTextRange.size = lib.ImVector_ImGuiTextRange_size +ImVector_ImGuiTextRange.size_in_bytes = lib.ImVector_ImGuiTextRange_size_in_bytes +ImVector_ImGuiTextRange.swap = lib.ImVector_ImGuiTextRange_swap +M.ImVector_ImGuiTextRange = ffi.metatype("ImVector_ImGuiTextRange",ImVector_ImGuiTextRange) +--------------------------ImVector_float---------------------------- +local ImVector_float= {} +ImVector_float.__index = ImVector_float +function ImVector_float.__new(ctype) + local ptr = lib.ImVector_float_ImVector_float() + return ffi.gc(ptr,lib.ImVector_float_destroy) +end +function ImVector_float.ImVector_floatVector(src) + local ptr = lib.ImVector_float_ImVector_floatVector(src) + return ffi.gc(ptr,lib.ImVector_float_destroy) +end +ImVector_float._grow_capacity = lib.ImVector_float__grow_capacity +ImVector_float.back = lib.ImVector_float_back +ImVector_float.back_const = lib.ImVector_float_back_const +ImVector_float.begin = lib.ImVector_float_begin +ImVector_float.begin_const = lib.ImVector_float_begin_const +ImVector_float.capacity = lib.ImVector_float_capacity +ImVector_float.clear = lib.ImVector_float_clear +ImVector_float.contains = lib.ImVector_float_contains +ImVector_float.empty = lib.ImVector_float_empty +ImVector_float._end = lib.ImVector_float_end +ImVector_float.end_const = lib.ImVector_float_end_const +ImVector_float.erase = lib.ImVector_float_erase +ImVector_float.eraseTPtr = lib.ImVector_float_eraseTPtr +ImVector_float.erase_unsorted = lib.ImVector_float_erase_unsorted +ImVector_float.front = lib.ImVector_float_front +ImVector_float.front_const = lib.ImVector_float_front_const +ImVector_float.index_from_ptr = lib.ImVector_float_index_from_ptr +ImVector_float.insert = lib.ImVector_float_insert +ImVector_float.pop_back = lib.ImVector_float_pop_back +ImVector_float.push_back = lib.ImVector_float_push_back +ImVector_float.push_front = lib.ImVector_float_push_front +ImVector_float.reserve = lib.ImVector_float_reserve +ImVector_float.resize = lib.ImVector_float_resize +ImVector_float.resizeT = lib.ImVector_float_resizeT +ImVector_float.size = lib.ImVector_float_size +ImVector_float.size_in_bytes = lib.ImVector_float_size_in_bytes +ImVector_float.swap = lib.ImVector_float_swap +M.ImVector_float = ffi.metatype("ImVector_float",ImVector_float) +--------------------------ImGuiInputTextCallbackData---------------------------- +local ImGuiInputTextCallbackData= {} +ImGuiInputTextCallbackData.__index = ImGuiInputTextCallbackData +ImGuiInputTextCallbackData.DeleteChars = lib.ImGuiInputTextCallbackData_DeleteChars +ImGuiInputTextCallbackData.HasSelection = lib.ImGuiInputTextCallbackData_HasSelection +function ImGuiInputTextCallbackData.__new(ctype) + local ptr = lib.ImGuiInputTextCallbackData_ImGuiInputTextCallbackData() + return ffi.gc(ptr,lib.ImGuiInputTextCallbackData_destroy) +end +function ImGuiInputTextCallbackData:InsertChars(pos,text,text_end) + text_end = text_end or nil + return lib.ImGuiInputTextCallbackData_InsertChars(self,pos,text,text_end) +end +M.ImGuiInputTextCallbackData = ffi.metatype("ImGuiInputTextCallbackData",ImGuiInputTextCallbackData) +--------------------------ImGuiPayload---------------------------- +local ImGuiPayload= {} +ImGuiPayload.__index = ImGuiPayload +ImGuiPayload.Clear = lib.ImGuiPayload_Clear +function ImGuiPayload.__new(ctype) + local ptr = lib.ImGuiPayload_ImGuiPayload() + return ffi.gc(ptr,lib.ImGuiPayload_destroy) +end +ImGuiPayload.IsDataType = lib.ImGuiPayload_IsDataType +ImGuiPayload.IsDelivery = lib.ImGuiPayload_IsDelivery +ImGuiPayload.IsPreview = lib.ImGuiPayload_IsPreview +M.ImGuiPayload = ffi.metatype("ImGuiPayload",ImGuiPayload) +--------------------------ImDrawCmd---------------------------- +local ImDrawCmd= {} +ImDrawCmd.__index = ImDrawCmd +function ImDrawCmd.__new(ctype) + local ptr = lib.ImDrawCmd_ImDrawCmd() + return ffi.gc(ptr,lib.ImDrawCmd_destroy) +end +M.ImDrawCmd = ffi.metatype("ImDrawCmd",ImDrawCmd) +--------------------------ImVector_ImFontGlyph---------------------------- +local ImVector_ImFontGlyph= {} +ImVector_ImFontGlyph.__index = ImVector_ImFontGlyph +function ImVector_ImFontGlyph.__new(ctype) + local ptr = lib.ImVector_ImFontGlyph_ImVector_ImFontGlyph() + return ffi.gc(ptr,lib.ImVector_ImFontGlyph_destroy) +end +function ImVector_ImFontGlyph.ImVector_ImFontGlyphVector(src) + local ptr = lib.ImVector_ImFontGlyph_ImVector_ImFontGlyphVector(src) + return ffi.gc(ptr,lib.ImVector_ImFontGlyph_destroy) +end +ImVector_ImFontGlyph._grow_capacity = lib.ImVector_ImFontGlyph__grow_capacity +ImVector_ImFontGlyph.back = lib.ImVector_ImFontGlyph_back +ImVector_ImFontGlyph.back_const = lib.ImVector_ImFontGlyph_back_const +ImVector_ImFontGlyph.begin = lib.ImVector_ImFontGlyph_begin +ImVector_ImFontGlyph.begin_const = lib.ImVector_ImFontGlyph_begin_const +ImVector_ImFontGlyph.capacity = lib.ImVector_ImFontGlyph_capacity +ImVector_ImFontGlyph.clear = lib.ImVector_ImFontGlyph_clear +ImVector_ImFontGlyph.empty = lib.ImVector_ImFontGlyph_empty +ImVector_ImFontGlyph._end = lib.ImVector_ImFontGlyph_end +ImVector_ImFontGlyph.end_const = lib.ImVector_ImFontGlyph_end_const +ImVector_ImFontGlyph.erase = lib.ImVector_ImFontGlyph_erase +ImVector_ImFontGlyph.eraseTPtr = lib.ImVector_ImFontGlyph_eraseTPtr +ImVector_ImFontGlyph.erase_unsorted = lib.ImVector_ImFontGlyph_erase_unsorted +ImVector_ImFontGlyph.front = lib.ImVector_ImFontGlyph_front +ImVector_ImFontGlyph.front_const = lib.ImVector_ImFontGlyph_front_const +ImVector_ImFontGlyph.index_from_ptr = lib.ImVector_ImFontGlyph_index_from_ptr +ImVector_ImFontGlyph.insert = lib.ImVector_ImFontGlyph_insert +ImVector_ImFontGlyph.pop_back = lib.ImVector_ImFontGlyph_pop_back +ImVector_ImFontGlyph.push_back = lib.ImVector_ImFontGlyph_push_back +ImVector_ImFontGlyph.push_front = lib.ImVector_ImFontGlyph_push_front +ImVector_ImFontGlyph.reserve = lib.ImVector_ImFontGlyph_reserve +ImVector_ImFontGlyph.resize = lib.ImVector_ImFontGlyph_resize +ImVector_ImFontGlyph.resizeT = lib.ImVector_ImFontGlyph_resizeT +ImVector_ImFontGlyph.size = lib.ImVector_ImFontGlyph_size +ImVector_ImFontGlyph.size_in_bytes = lib.ImVector_ImFontGlyph_size_in_bytes +ImVector_ImFontGlyph.swap = lib.ImVector_ImFontGlyph_swap +M.ImVector_ImFontGlyph = ffi.metatype("ImVector_ImFontGlyph",ImVector_ImFontGlyph) +--------------------------ImGuiTextFilter---------------------------- +local ImGuiTextFilter= {} +ImGuiTextFilter.__index = ImGuiTextFilter +ImGuiTextFilter.Build = lib.ImGuiTextFilter_Build +ImGuiTextFilter.Clear = lib.ImGuiTextFilter_Clear +function ImGuiTextFilter:Draw(label,width) + label = label or "Filter(inc,-exc)" + width = width or 0.0 + return lib.ImGuiTextFilter_Draw(self,label,width) +end +function ImGuiTextFilter.__new(ctype,default_filter) + if default_filter == nil then default_filter = "" end + local ptr = lib.ImGuiTextFilter_ImGuiTextFilter(default_filter) + return ffi.gc(ptr,lib.ImGuiTextFilter_destroy) +end +ImGuiTextFilter.IsActive = lib.ImGuiTextFilter_IsActive +function ImGuiTextFilter:PassFilter(text,text_end) + text_end = text_end or nil + return lib.ImGuiTextFilter_PassFilter(self,text,text_end) +end +M.ImGuiTextFilter = ffi.metatype("ImGuiTextFilter",ImGuiTextFilter) +--------------------------ImVector_ImGuiStoragePair---------------------------- +local ImVector_ImGuiStoragePair= {} +ImVector_ImGuiStoragePair.__index = ImVector_ImGuiStoragePair +function ImVector_ImGuiStoragePair.__new(ctype) + local ptr = lib.ImVector_ImGuiStoragePair_ImVector_ImGuiStoragePair() + return ffi.gc(ptr,lib.ImVector_ImGuiStoragePair_destroy) +end +function ImVector_ImGuiStoragePair.ImVector_ImGuiStoragePairVector(src) + local ptr = lib.ImVector_ImGuiStoragePair_ImVector_ImGuiStoragePairVector(src) + return ffi.gc(ptr,lib.ImVector_ImGuiStoragePair_destroy) +end +ImVector_ImGuiStoragePair._grow_capacity = lib.ImVector_ImGuiStoragePair__grow_capacity +ImVector_ImGuiStoragePair.back = lib.ImVector_ImGuiStoragePair_back +ImVector_ImGuiStoragePair.back_const = lib.ImVector_ImGuiStoragePair_back_const +ImVector_ImGuiStoragePair.begin = lib.ImVector_ImGuiStoragePair_begin +ImVector_ImGuiStoragePair.begin_const = lib.ImVector_ImGuiStoragePair_begin_const +ImVector_ImGuiStoragePair.capacity = lib.ImVector_ImGuiStoragePair_capacity +ImVector_ImGuiStoragePair.clear = lib.ImVector_ImGuiStoragePair_clear +ImVector_ImGuiStoragePair.empty = lib.ImVector_ImGuiStoragePair_empty +ImVector_ImGuiStoragePair._end = lib.ImVector_ImGuiStoragePair_end +ImVector_ImGuiStoragePair.end_const = lib.ImVector_ImGuiStoragePair_end_const +ImVector_ImGuiStoragePair.erase = lib.ImVector_ImGuiStoragePair_erase +ImVector_ImGuiStoragePair.eraseTPtr = lib.ImVector_ImGuiStoragePair_eraseTPtr +ImVector_ImGuiStoragePair.erase_unsorted = lib.ImVector_ImGuiStoragePair_erase_unsorted +ImVector_ImGuiStoragePair.front = lib.ImVector_ImGuiStoragePair_front +ImVector_ImGuiStoragePair.front_const = lib.ImVector_ImGuiStoragePair_front_const +ImVector_ImGuiStoragePair.index_from_ptr = lib.ImVector_ImGuiStoragePair_index_from_ptr +ImVector_ImGuiStoragePair.insert = lib.ImVector_ImGuiStoragePair_insert +ImVector_ImGuiStoragePair.pop_back = lib.ImVector_ImGuiStoragePair_pop_back +ImVector_ImGuiStoragePair.push_back = lib.ImVector_ImGuiStoragePair_push_back +ImVector_ImGuiStoragePair.push_front = lib.ImVector_ImGuiStoragePair_push_front +ImVector_ImGuiStoragePair.reserve = lib.ImVector_ImGuiStoragePair_reserve +ImVector_ImGuiStoragePair.resize = lib.ImVector_ImGuiStoragePair_resize +ImVector_ImGuiStoragePair.resizeT = lib.ImVector_ImGuiStoragePair_resizeT +ImVector_ImGuiStoragePair.size = lib.ImVector_ImGuiStoragePair_size +ImVector_ImGuiStoragePair.size_in_bytes = lib.ImVector_ImGuiStoragePair_size_in_bytes +ImVector_ImGuiStoragePair.swap = lib.ImVector_ImGuiStoragePair_swap +M.ImVector_ImGuiStoragePair = ffi.metatype("ImVector_ImGuiStoragePair",ImVector_ImGuiStoragePair) +--------------------------ImFontAtlas---------------------------- +local ImFontAtlas= {} +ImFontAtlas.__index = ImFontAtlas +function ImFontAtlas:AddCustomRectFontGlyph(font,id,width,height,advance_x,offset) + offset = offset or ImVec2(0,0) + return lib.ImFontAtlas_AddCustomRectFontGlyph(self,font,id,width,height,advance_x,offset) +end +ImFontAtlas.AddCustomRectRegular = lib.ImFontAtlas_AddCustomRectRegular +ImFontAtlas.AddFont = lib.ImFontAtlas_AddFont +function ImFontAtlas:AddFontDefault(font_cfg) + font_cfg = font_cfg or nil + return lib.ImFontAtlas_AddFontDefault(self,font_cfg) +end +function ImFontAtlas:AddFontFromFileTTF(filename,size_pixels,font_cfg,glyph_ranges) + glyph_ranges = glyph_ranges or nil + font_cfg = font_cfg or nil + return lib.ImFontAtlas_AddFontFromFileTTF(self,filename,size_pixels,font_cfg,glyph_ranges) +end +function ImFontAtlas:AddFontFromMemoryCompressedBase85TTF(compressed_font_data_base85,size_pixels,font_cfg,glyph_ranges) + glyph_ranges = glyph_ranges or nil + font_cfg = font_cfg or nil + return lib.ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(self,compressed_font_data_base85,size_pixels,font_cfg,glyph_ranges) +end +function ImFontAtlas:AddFontFromMemoryCompressedTTF(compressed_font_data,compressed_font_size,size_pixels,font_cfg,glyph_ranges) + glyph_ranges = glyph_ranges or nil + font_cfg = font_cfg or nil + return lib.ImFontAtlas_AddFontFromMemoryCompressedTTF(self,compressed_font_data,compressed_font_size,size_pixels,font_cfg,glyph_ranges) +end +function ImFontAtlas:AddFontFromMemoryTTF(font_data,font_size,size_pixels,font_cfg,glyph_ranges) + glyph_ranges = glyph_ranges or nil + font_cfg = font_cfg or nil + return lib.ImFontAtlas_AddFontFromMemoryTTF(self,font_data,font_size,size_pixels,font_cfg,glyph_ranges) +end +ImFontAtlas.Build = lib.ImFontAtlas_Build +ImFontAtlas.CalcCustomRectUV = lib.ImFontAtlas_CalcCustomRectUV +ImFontAtlas.Clear = lib.ImFontAtlas_Clear +ImFontAtlas.ClearFonts = lib.ImFontAtlas_ClearFonts +ImFontAtlas.ClearInputData = lib.ImFontAtlas_ClearInputData +ImFontAtlas.ClearTexData = lib.ImFontAtlas_ClearTexData +ImFontAtlas.GetCustomRectByIndex = lib.ImFontAtlas_GetCustomRectByIndex +ImFontAtlas.GetGlyphRangesChineseFull = lib.ImFontAtlas_GetGlyphRangesChineseFull +ImFontAtlas.GetGlyphRangesChineseSimplifiedCommon = lib.ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon +ImFontAtlas.GetGlyphRangesCyrillic = lib.ImFontAtlas_GetGlyphRangesCyrillic +ImFontAtlas.GetGlyphRangesDefault = lib.ImFontAtlas_GetGlyphRangesDefault +ImFontAtlas.GetGlyphRangesJapanese = lib.ImFontAtlas_GetGlyphRangesJapanese +ImFontAtlas.GetGlyphRangesKorean = lib.ImFontAtlas_GetGlyphRangesKorean +ImFontAtlas.GetGlyphRangesThai = lib.ImFontAtlas_GetGlyphRangesThai +ImFontAtlas.GetGlyphRangesVietnamese = lib.ImFontAtlas_GetGlyphRangesVietnamese +ImFontAtlas.GetMouseCursorTexData = lib.ImFontAtlas_GetMouseCursorTexData +function ImFontAtlas:GetTexDataAsAlpha8(out_pixels,out_width,out_height,out_bytes_per_pixel) + out_bytes_per_pixel = out_bytes_per_pixel or nil + return lib.ImFontAtlas_GetTexDataAsAlpha8(self,out_pixels,out_width,out_height,out_bytes_per_pixel) +end +function ImFontAtlas:GetTexDataAsRGBA32(out_pixels,out_width,out_height,out_bytes_per_pixel) + out_bytes_per_pixel = out_bytes_per_pixel or nil + return lib.ImFontAtlas_GetTexDataAsRGBA32(self,out_pixels,out_width,out_height,out_bytes_per_pixel) +end +function ImFontAtlas.__new(ctype) + local ptr = lib.ImFontAtlas_ImFontAtlas() + return ffi.gc(ptr,lib.ImFontAtlas_destroy) +end +ImFontAtlas.IsBuilt = lib.ImFontAtlas_IsBuilt +ImFontAtlas.SetTexID = lib.ImFontAtlas_SetTexID +M.ImFontAtlas = ffi.metatype("ImFontAtlas",ImFontAtlas) +------------------------------------------------------ +function M.AcceptDragDropPayload(type,flags) + flags = flags or 0 + return lib.igAcceptDragDropPayload(type,flags) +end +M.AlignTextToFramePadding = lib.igAlignTextToFramePadding +M.ArrowButton = lib.igArrowButton +function M.Begin(name,p_open,flags) + p_open = p_open or nil + flags = flags or 0 + return lib.igBegin(name,p_open,flags) +end +function M.BeginChild(str_id,size,border,flags) + border = border or false + size = size or ImVec2(0,0) + flags = flags or 0 + return lib.igBeginChild(str_id,size,border,flags) +end +function M.BeginChildID(id,size,border,flags) + border = border or false + size = size or ImVec2(0,0) + flags = flags or 0 + return lib.igBeginChildID(id,size,border,flags) +end +function M.BeginChildFrame(id,size,flags) + flags = flags or 0 + return lib.igBeginChildFrame(id,size,flags) +end +function M.BeginCombo(label,preview_value,flags) + flags = flags or 0 + return lib.igBeginCombo(label,preview_value,flags) +end +function M.BeginDragDropSource(flags) + flags = flags or 0 + return lib.igBeginDragDropSource(flags) +end +M.BeginDragDropTarget = lib.igBeginDragDropTarget +M.BeginGroup = lib.igBeginGroup +M.BeginMainMenuBar = lib.igBeginMainMenuBar +function M.BeginMenu(label,enabled) + if enabled == nil then enabled = true end + return lib.igBeginMenu(label,enabled) +end +M.BeginMenuBar = lib.igBeginMenuBar +function M.BeginPopup(str_id,flags) + flags = flags or 0 + return lib.igBeginPopup(str_id,flags) +end +function M.BeginPopupContextItem(str_id,mouse_button) + mouse_button = mouse_button or 1 + str_id = str_id or nil + return lib.igBeginPopupContextItem(str_id,mouse_button) +end +function M.BeginPopupContextVoid(str_id,mouse_button) + mouse_button = mouse_button or 1 + str_id = str_id or nil + return lib.igBeginPopupContextVoid(str_id,mouse_button) +end +function M.BeginPopupContextWindow(str_id,mouse_button,also_over_items) + if also_over_items == nil then also_over_items = true end + mouse_button = mouse_button or 1 + str_id = str_id or nil + return lib.igBeginPopupContextWindow(str_id,mouse_button,also_over_items) +end +function M.BeginPopupModal(name,p_open,flags) + p_open = p_open or nil + flags = flags or 0 + return lib.igBeginPopupModal(name,p_open,flags) +end +function M.BeginTabBar(str_id,flags) + flags = flags or 0 + return lib.igBeginTabBar(str_id,flags) +end +function M.BeginTabItem(label,p_open,flags) + p_open = p_open or nil + flags = flags or 0 + return lib.igBeginTabItem(label,p_open,flags) +end +M.BeginTooltip = lib.igBeginTooltip +M.Bullet = lib.igBullet +M.BulletText = lib.igBulletText +M.BulletTextV = lib.igBulletTextV +function M.Button(label,size) + size = size or ImVec2(0,0) + return lib.igButton(label,size) +end +M.CalcItemWidth = lib.igCalcItemWidth +M.CalcListClipping = lib.igCalcListClipping +function M.CalcTextSize(text,text_end,hide_text_after_double_hash,wrap_width) + text_end = text_end or nil + wrap_width = wrap_width or -1.0 + hide_text_after_double_hash = hide_text_after_double_hash or false + local nonUDT_out = ffi.new("ImVec2") + lib.igCalcTextSize_nonUDT(nonUDT_out,text,text_end,hide_text_after_double_hash,wrap_width) + return nonUDT_out +end +function M.CalcTextSize_nonUDT2(text,text_end,hide_text_after_double_hash,wrap_width) + text_end = text_end or nil + wrap_width = wrap_width or -1.0 + hide_text_after_double_hash = hide_text_after_double_hash or false + return lib.igCalcTextSize_nonUDT2(text,text_end,hide_text_after_double_hash,wrap_width) +end +function M.CaptureKeyboardFromApp(want_capture_keyboard_value) + if want_capture_keyboard_value == nil then want_capture_keyboard_value = true end + return lib.igCaptureKeyboardFromApp(want_capture_keyboard_value) +end +function M.CaptureMouseFromApp(want_capture_mouse_value) + if want_capture_mouse_value == nil then want_capture_mouse_value = true end + return lib.igCaptureMouseFromApp(want_capture_mouse_value) +end +M.Checkbox = lib.igCheckbox +M.CheckboxFlags = lib.igCheckboxFlags +M.CloseCurrentPopup = lib.igCloseCurrentPopup +function M.CollapsingHeader(label,flags) + flags = flags or 0 + return lib.igCollapsingHeader(label,flags) +end +function M.CollapsingHeaderBoolPtr(label,p_open,flags) + flags = flags or 0 + return lib.igCollapsingHeaderBoolPtr(label,p_open,flags) +end +function M.ColorButton(desc_id,col,flags,size) + size = size or ImVec2(0,0) + flags = flags or 0 + return lib.igColorButton(desc_id,col,flags,size) +end +M.ColorConvertFloat4ToU32 = lib.igColorConvertFloat4ToU32 +M.ColorConvertHSVtoRGB = lib.igColorConvertHSVtoRGB +M.ColorConvertRGBtoHSV = lib.igColorConvertRGBtoHSV +function M.ColorConvertU32ToFloat4(_in) + local nonUDT_out = ffi.new("ImVec4") + lib.igColorConvertU32ToFloat4_nonUDT(nonUDT_out,_in) + return nonUDT_out +end +M.ColorConvertU32ToFloat4_nonUDT2 = lib.igColorConvertU32ToFloat4_nonUDT2 +function M.ColorEdit3(label,col,flags) + flags = flags or 0 + return lib.igColorEdit3(label,col,flags) +end +function M.ColorEdit4(label,col,flags) + flags = flags or 0 + return lib.igColorEdit4(label,col,flags) +end +function M.ColorPicker3(label,col,flags) + flags = flags or 0 + return lib.igColorPicker3(label,col,flags) +end +function M.ColorPicker4(label,col,flags,ref_col) + ref_col = ref_col or nil + flags = flags or 0 + return lib.igColorPicker4(label,col,flags,ref_col) +end +function M.Columns(count,id,border) + if border == nil then border = true end + count = count or 1 + id = id or nil + return lib.igColumns(count,id,border) +end +function M.Combo(label,current_item,items,items_count,popup_max_height_in_items) + popup_max_height_in_items = popup_max_height_in_items or -1 + return lib.igCombo(label,current_item,items,items_count,popup_max_height_in_items) +end +function M.ComboStr(label,current_item,items_separated_by_zeros,popup_max_height_in_items) + popup_max_height_in_items = popup_max_height_in_items or -1 + return lib.igComboStr(label,current_item,items_separated_by_zeros,popup_max_height_in_items) +end +function M.ComboFnPtr(label,current_item,items_getter,data,items_count,popup_max_height_in_items) + popup_max_height_in_items = popup_max_height_in_items or -1 + return lib.igComboFnPtr(label,current_item,items_getter,data,items_count,popup_max_height_in_items) +end +function M.CreateContext(shared_font_atlas) + shared_font_atlas = shared_font_atlas or nil + return lib.igCreateContext(shared_font_atlas) +end +M.DebugCheckVersionAndDataLayout = lib.igDebugCheckVersionAndDataLayout +function M.DestroyContext(ctx) + ctx = ctx or nil + return lib.igDestroyContext(ctx) +end +function M.DragFloat(label,v,v_speed,v_min,v_max,format,power) + v_max = v_max or 0.0 + format = format or "%.3f" + power = power or 1.0 + v_speed = v_speed or 1.0 + v_min = v_min or 0.0 + return lib.igDragFloat(label,v,v_speed,v_min,v_max,format,power) +end +function M.DragFloat2(label,v,v_speed,v_min,v_max,format,power) + v_max = v_max or 0.0 + format = format or "%.3f" + power = power or 1.0 + v_speed = v_speed or 1.0 + v_min = v_min or 0.0 + return lib.igDragFloat2(label,v,v_speed,v_min,v_max,format,power) +end +function M.DragFloat3(label,v,v_speed,v_min,v_max,format,power) + v_max = v_max or 0.0 + format = format or "%.3f" + power = power or 1.0 + v_speed = v_speed or 1.0 + v_min = v_min or 0.0 + return lib.igDragFloat3(label,v,v_speed,v_min,v_max,format,power) +end +function M.DragFloat4(label,v,v_speed,v_min,v_max,format,power) + v_max = v_max or 0.0 + format = format or "%.3f" + power = power or 1.0 + v_speed = v_speed or 1.0 + v_min = v_min or 0.0 + return lib.igDragFloat4(label,v,v_speed,v_min,v_max,format,power) +end +function M.DragFloatRange2(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max,power) + format_max = format_max or nil + format = format or "%.3f" + power = power or 1.0 + v_speed = v_speed or 1.0 + v_min = v_min or 0.0 + v_max = v_max or 0.0 + return lib.igDragFloatRange2(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max,power) +end +function M.DragInt(label,v,v_speed,v_min,v_max,format) + v_max = v_max or 0 + format = format or "%d" + v_speed = v_speed or 1.0 + v_min = v_min or 0 + return lib.igDragInt(label,v,v_speed,v_min,v_max,format) +end +function M.DragInt2(label,v,v_speed,v_min,v_max,format) + v_max = v_max or 0 + format = format or "%d" + v_speed = v_speed or 1.0 + v_min = v_min or 0 + return lib.igDragInt2(label,v,v_speed,v_min,v_max,format) +end +function M.DragInt3(label,v,v_speed,v_min,v_max,format) + v_max = v_max or 0 + format = format or "%d" + v_speed = v_speed or 1.0 + v_min = v_min or 0 + return lib.igDragInt3(label,v,v_speed,v_min,v_max,format) +end +function M.DragInt4(label,v,v_speed,v_min,v_max,format) + v_max = v_max or 0 + format = format or "%d" + v_speed = v_speed or 1.0 + v_min = v_min or 0 + return lib.igDragInt4(label,v,v_speed,v_min,v_max,format) +end +function M.DragIntRange2(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max) + format_max = format_max or nil + format = format or "%d" + v_speed = v_speed or 1.0 + v_max = v_max or 0 + v_min = v_min or 0 + return lib.igDragIntRange2(label,v_current_min,v_current_max,v_speed,v_min,v_max,format,format_max) +end +function M.DragScalar(label,data_type,v,v_speed,v_min,v_max,format,power) + v_max = v_max or nil + format = format or nil + v_min = v_min or nil + power = power or 1.0 + return lib.igDragScalar(label,data_type,v,v_speed,v_min,v_max,format,power) +end +function M.DragScalarN(label,data_type,v,components,v_speed,v_min,v_max,format,power) + v_max = v_max or nil + format = format or nil + v_min = v_min or nil + power = power or 1.0 + return lib.igDragScalarN(label,data_type,v,components,v_speed,v_min,v_max,format,power) +end +M.Dummy = lib.igDummy +M.End = lib.igEnd +M.EndChild = lib.igEndChild +M.EndChildFrame = lib.igEndChildFrame +M.EndCombo = lib.igEndCombo +M.EndDragDropSource = lib.igEndDragDropSource +M.EndDragDropTarget = lib.igEndDragDropTarget +M.EndFrame = lib.igEndFrame +M.EndGroup = lib.igEndGroup +M.EndMainMenuBar = lib.igEndMainMenuBar +M.EndMenu = lib.igEndMenu +M.EndMenuBar = lib.igEndMenuBar +M.EndPopup = lib.igEndPopup +M.EndTabBar = lib.igEndTabBar +M.EndTabItem = lib.igEndTabItem +M.EndTooltip = lib.igEndTooltip +M.GetBackgroundDrawList = lib.igGetBackgroundDrawList +M.GetClipboardText = lib.igGetClipboardText +function M.GetColorU32(idx,alpha_mul) + alpha_mul = alpha_mul or 1.0 + return lib.igGetColorU32(idx,alpha_mul) +end +M.GetColorU32Vec4 = lib.igGetColorU32Vec4 +M.GetColorU32U32 = lib.igGetColorU32U32 +M.GetColumnIndex = lib.igGetColumnIndex +function M.GetColumnOffset(column_index) + column_index = column_index or -1 + return lib.igGetColumnOffset(column_index) +end +function M.GetColumnWidth(column_index) + column_index = column_index or -1 + return lib.igGetColumnWidth(column_index) +end +M.GetColumnsCount = lib.igGetColumnsCount +function M.GetContentRegionAvail() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetContentRegionAvail_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetContentRegionAvail_nonUDT2 = lib.igGetContentRegionAvail_nonUDT2 +function M.GetContentRegionMax() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetContentRegionMax_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetContentRegionMax_nonUDT2 = lib.igGetContentRegionMax_nonUDT2 +M.GetCurrentContext = lib.igGetCurrentContext +function M.GetCursorPos() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetCursorPos_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetCursorPos_nonUDT2 = lib.igGetCursorPos_nonUDT2 +M.GetCursorPosX = lib.igGetCursorPosX +M.GetCursorPosY = lib.igGetCursorPosY +function M.GetCursorScreenPos() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetCursorScreenPos_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetCursorScreenPos_nonUDT2 = lib.igGetCursorScreenPos_nonUDT2 +function M.GetCursorStartPos() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetCursorStartPos_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetCursorStartPos_nonUDT2 = lib.igGetCursorStartPos_nonUDT2 +M.GetDragDropPayload = lib.igGetDragDropPayload +M.GetDrawData = lib.igGetDrawData +M.GetDrawListSharedData = lib.igGetDrawListSharedData +M.GetFont = lib.igGetFont +M.GetFontSize = lib.igGetFontSize +function M.GetFontTexUvWhitePixel() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetFontTexUvWhitePixel_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetFontTexUvWhitePixel_nonUDT2 = lib.igGetFontTexUvWhitePixel_nonUDT2 +M.GetForegroundDrawList = lib.igGetForegroundDrawList +M.GetFrameCount = lib.igGetFrameCount +M.GetFrameHeight = lib.igGetFrameHeight +M.GetFrameHeightWithSpacing = lib.igGetFrameHeightWithSpacing +M.GetIDStr = lib.igGetIDStr +M.GetIDRange = lib.igGetIDRange +M.GetIDPtr = lib.igGetIDPtr +M.GetIO = lib.igGetIO +function M.GetItemRectMax() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetItemRectMax_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetItemRectMax_nonUDT2 = lib.igGetItemRectMax_nonUDT2 +function M.GetItemRectMin() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetItemRectMin_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetItemRectMin_nonUDT2 = lib.igGetItemRectMin_nonUDT2 +function M.GetItemRectSize() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetItemRectSize_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetItemRectSize_nonUDT2 = lib.igGetItemRectSize_nonUDT2 +M.GetKeyIndex = lib.igGetKeyIndex +M.GetKeyPressedAmount = lib.igGetKeyPressedAmount +M.GetMouseCursor = lib.igGetMouseCursor +function M.GetMouseDragDelta(button,lock_threshold) + lock_threshold = lock_threshold or -1.0 + button = button or 0 + local nonUDT_out = ffi.new("ImVec2") + lib.igGetMouseDragDelta_nonUDT(nonUDT_out,button,lock_threshold) + return nonUDT_out +end +function M.GetMouseDragDelta_nonUDT2(button,lock_threshold) + lock_threshold = lock_threshold or -1.0 + button = button or 0 + return lib.igGetMouseDragDelta_nonUDT2(button,lock_threshold) +end +function M.GetMousePos() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetMousePos_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetMousePos_nonUDT2 = lib.igGetMousePos_nonUDT2 +function M.GetMousePosOnOpeningCurrentPopup() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetMousePosOnOpeningCurrentPopup_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetMousePosOnOpeningCurrentPopup_nonUDT2 = lib.igGetMousePosOnOpeningCurrentPopup_nonUDT2 +M.GetScrollMaxX = lib.igGetScrollMaxX +M.GetScrollMaxY = lib.igGetScrollMaxY +M.GetScrollX = lib.igGetScrollX +M.GetScrollY = lib.igGetScrollY +M.GetStateStorage = lib.igGetStateStorage +M.GetStyle = lib.igGetStyle +M.GetStyleColorName = lib.igGetStyleColorName +M.GetStyleColorVec4 = lib.igGetStyleColorVec4 +M.GetTextLineHeight = lib.igGetTextLineHeight +M.GetTextLineHeightWithSpacing = lib.igGetTextLineHeightWithSpacing +M.GetTime = lib.igGetTime +M.GetTreeNodeToLabelSpacing = lib.igGetTreeNodeToLabelSpacing +M.GetVersion = lib.igGetVersion +function M.GetWindowContentRegionMax() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetWindowContentRegionMax_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetWindowContentRegionMax_nonUDT2 = lib.igGetWindowContentRegionMax_nonUDT2 +function M.GetWindowContentRegionMin() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetWindowContentRegionMin_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetWindowContentRegionMin_nonUDT2 = lib.igGetWindowContentRegionMin_nonUDT2 +M.GetWindowContentRegionWidth = lib.igGetWindowContentRegionWidth +M.GetWindowDrawList = lib.igGetWindowDrawList +M.GetWindowHeight = lib.igGetWindowHeight +function M.GetWindowPos() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetWindowPos_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetWindowPos_nonUDT2 = lib.igGetWindowPos_nonUDT2 +function M.GetWindowSize() + local nonUDT_out = ffi.new("ImVec2") + lib.igGetWindowSize_nonUDT(nonUDT_out) + return nonUDT_out +end +M.GetWindowSize_nonUDT2 = lib.igGetWindowSize_nonUDT2 +M.GetWindowWidth = lib.igGetWindowWidth +function M.Image(user_texture_id,size,uv0,uv1,tint_col,border_col) + border_col = border_col or ImVec4(0,0,0,0) + tint_col = tint_col or ImVec4(1,1,1,1) + uv0 = uv0 or ImVec2(0,0) + uv1 = uv1 or ImVec2(1,1) + return lib.igImage(user_texture_id,size,uv0,uv1,tint_col,border_col) +end +function M.ImageButton(user_texture_id,size,uv0,uv1,frame_padding,bg_col,tint_col) + uv1 = uv1 or ImVec2(1,1) + bg_col = bg_col or ImVec4(0,0,0,0) + uv0 = uv0 or ImVec2(0,0) + tint_col = tint_col or ImVec4(1,1,1,1) + frame_padding = frame_padding or -1 + return lib.igImageButton(user_texture_id,size,uv0,uv1,frame_padding,bg_col,tint_col) +end +function M.Indent(indent_w) + indent_w = indent_w or 0.0 + return lib.igIndent(indent_w) +end +function M.InputDouble(label,v,step,step_fast,format,flags) + step = step or 0.0 + format = format or "%.6f" + step_fast = step_fast or 0.0 + flags = flags or 0 + return lib.igInputDouble(label,v,step,step_fast,format,flags) +end +function M.InputFloat(label,v,step,step_fast,format,flags) + step = step or 0.0 + format = format or "%.3f" + step_fast = step_fast or 0.0 + flags = flags or 0 + return lib.igInputFloat(label,v,step,step_fast,format,flags) +end +function M.InputFloat2(label,v,format,flags) + format = format or "%.3f" + flags = flags or 0 + return lib.igInputFloat2(label,v,format,flags) +end +function M.InputFloat3(label,v,format,flags) + format = format or "%.3f" + flags = flags or 0 + return lib.igInputFloat3(label,v,format,flags) +end +function M.InputFloat4(label,v,format,flags) + format = format or "%.3f" + flags = flags or 0 + return lib.igInputFloat4(label,v,format,flags) +end +function M.InputInt(label,v,step,step_fast,flags) + step = step or 1 + step_fast = step_fast or 100 + flags = flags or 0 + return lib.igInputInt(label,v,step,step_fast,flags) +end +function M.InputInt2(label,v,flags) + flags = flags or 0 + return lib.igInputInt2(label,v,flags) +end +function M.InputInt3(label,v,flags) + flags = flags or 0 + return lib.igInputInt3(label,v,flags) +end +function M.InputInt4(label,v,flags) + flags = flags or 0 + return lib.igInputInt4(label,v,flags) +end +function M.InputScalar(label,data_type,v,step,step_fast,format,flags) + step = step or nil + format = format or nil + step_fast = step_fast or nil + flags = flags or 0 + return lib.igInputScalar(label,data_type,v,step,step_fast,format,flags) +end +function M.InputScalarN(label,data_type,v,components,step,step_fast,format,flags) + step = step or nil + format = format or nil + step_fast = step_fast or nil + flags = flags or 0 + return lib.igInputScalarN(label,data_type,v,components,step,step_fast,format,flags) +end +function M.InputText(label,buf,buf_size,flags,callback,user_data) + callback = callback or nil + user_data = user_data or nil + flags = flags or 0 + return lib.igInputText(label,buf,buf_size,flags,callback,user_data) +end +function M.InputTextMultiline(label,buf,buf_size,size,flags,callback,user_data) + callback = callback or nil + user_data = user_data or nil + size = size or ImVec2(0,0) + flags = flags or 0 + return lib.igInputTextMultiline(label,buf,buf_size,size,flags,callback,user_data) +end +function M.InputTextWithHint(label,hint,buf,buf_size,flags,callback,user_data) + callback = callback or nil + user_data = user_data or nil + flags = flags or 0 + return lib.igInputTextWithHint(label,hint,buf,buf_size,flags,callback,user_data) +end +M.InvisibleButton = lib.igInvisibleButton +M.IsAnyItemActive = lib.igIsAnyItemActive +M.IsAnyItemFocused = lib.igIsAnyItemFocused +M.IsAnyItemHovered = lib.igIsAnyItemHovered +M.IsAnyMouseDown = lib.igIsAnyMouseDown +M.IsItemActivated = lib.igIsItemActivated +M.IsItemActive = lib.igIsItemActive +function M.IsItemClicked(mouse_button) + mouse_button = mouse_button or 0 + return lib.igIsItemClicked(mouse_button) +end +M.IsItemDeactivated = lib.igIsItemDeactivated +M.IsItemDeactivatedAfterEdit = lib.igIsItemDeactivatedAfterEdit +M.IsItemEdited = lib.igIsItemEdited +M.IsItemFocused = lib.igIsItemFocused +function M.IsItemHovered(flags) + flags = flags or 0 + return lib.igIsItemHovered(flags) +end +M.IsItemVisible = lib.igIsItemVisible +M.IsKeyDown = lib.igIsKeyDown +function M.IsKeyPressed(user_key_index,_repeat) + if _repeat == nil then _repeat = true end + return lib.igIsKeyPressed(user_key_index,_repeat) +end +M.IsKeyReleased = lib.igIsKeyReleased +function M.IsMouseClicked(button,_repeat) + _repeat = _repeat or false + return lib.igIsMouseClicked(button,_repeat) +end +M.IsMouseDoubleClicked = lib.igIsMouseDoubleClicked +M.IsMouseDown = lib.igIsMouseDown +function M.IsMouseDragging(button,lock_threshold) + lock_threshold = lock_threshold or -1.0 + button = button or 0 + return lib.igIsMouseDragging(button,lock_threshold) +end +function M.IsMouseHoveringRect(r_min,r_max,clip) + if clip == nil then clip = true end + return lib.igIsMouseHoveringRect(r_min,r_max,clip) +end +function M.IsMousePosValid(mouse_pos) + mouse_pos = mouse_pos or nil + return lib.igIsMousePosValid(mouse_pos) +end +M.IsMouseReleased = lib.igIsMouseReleased +M.IsPopupOpen = lib.igIsPopupOpen +M.IsRectVisible = lib.igIsRectVisible +M.IsRectVisibleVec2 = lib.igIsRectVisibleVec2 +M.IsWindowAppearing = lib.igIsWindowAppearing +M.IsWindowCollapsed = lib.igIsWindowCollapsed +function M.IsWindowFocused(flags) + flags = flags or 0 + return lib.igIsWindowFocused(flags) +end +function M.IsWindowHovered(flags) + flags = flags or 0 + return lib.igIsWindowHovered(flags) +end +M.LabelText = lib.igLabelText +M.LabelTextV = lib.igLabelTextV +function M.ListBoxStr_arr(label,current_item,items,items_count,height_in_items) + height_in_items = height_in_items or -1 + return lib.igListBoxStr_arr(label,current_item,items,items_count,height_in_items) +end +function M.ListBoxFnPtr(label,current_item,items_getter,data,items_count,height_in_items) + height_in_items = height_in_items or -1 + return lib.igListBoxFnPtr(label,current_item,items_getter,data,items_count,height_in_items) +end +M.ListBoxFooter = lib.igListBoxFooter +function M.ListBoxHeaderVec2(label,size) + size = size or ImVec2(0,0) + return lib.igListBoxHeaderVec2(label,size) +end +function M.ListBoxHeaderInt(label,items_count,height_in_items) + height_in_items = height_in_items or -1 + return lib.igListBoxHeaderInt(label,items_count,height_in_items) +end +M.LoadIniSettingsFromDisk = lib.igLoadIniSettingsFromDisk +function M.LoadIniSettingsFromMemory(ini_data,ini_size) + ini_size = ini_size or 0 + return lib.igLoadIniSettingsFromMemory(ini_data,ini_size) +end +M.LogButtons = lib.igLogButtons +M.LogFinish = lib.igLogFinish +M.LogText = lib.igLogText +function M.LogToClipboard(auto_open_depth) + auto_open_depth = auto_open_depth or -1 + return lib.igLogToClipboard(auto_open_depth) +end +function M.LogToFile(auto_open_depth,filename) + auto_open_depth = auto_open_depth or -1 + filename = filename or nil + return lib.igLogToFile(auto_open_depth,filename) +end +function M.LogToTTY(auto_open_depth) + auto_open_depth = auto_open_depth or -1 + return lib.igLogToTTY(auto_open_depth) +end +M.MemAlloc = lib.igMemAlloc +M.MemFree = lib.igMemFree +function M.MenuItemBool(label,shortcut,selected,enabled) + if enabled == nil then enabled = true end + shortcut = shortcut or nil + selected = selected or false + return lib.igMenuItemBool(label,shortcut,selected,enabled) +end +function M.MenuItemBoolPtr(label,shortcut,p_selected,enabled) + if enabled == nil then enabled = true end + return lib.igMenuItemBoolPtr(label,shortcut,p_selected,enabled) +end +M.NewFrame = lib.igNewFrame +M.NewLine = lib.igNewLine +M.NextColumn = lib.igNextColumn +M.OpenPopup = lib.igOpenPopup +function M.OpenPopupOnItemClick(str_id,mouse_button) + mouse_button = mouse_button or 1 + str_id = str_id or nil + return lib.igOpenPopupOnItemClick(str_id,mouse_button) +end +function M.PlotHistogramFloatPtr(label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride) + graph_size = graph_size or ImVec2(0,0) + values_offset = values_offset or 0 + scale_max = scale_max or M.FLT_MAX + scale_min = scale_min or M.FLT_MAX + stride = stride or ffi.sizeof("float") + overlay_text = overlay_text or nil + return lib.igPlotHistogramFloatPtr(label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride) +end +function M.PlotHistogramFnPtr(label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size) + graph_size = graph_size or ImVec2(0,0) + values_offset = values_offset or 0 + scale_max = scale_max or M.FLT_MAX + scale_min = scale_min or M.FLT_MAX + overlay_text = overlay_text or nil + return lib.igPlotHistogramFnPtr(label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size) +end +function M.PlotLines(label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride) + graph_size = graph_size or ImVec2(0,0) + values_offset = values_offset or 0 + scale_max = scale_max or M.FLT_MAX + scale_min = scale_min or M.FLT_MAX + stride = stride or ffi.sizeof("float") + overlay_text = overlay_text or nil + return lib.igPlotLines(label,values,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size,stride) +end +function M.PlotLinesFnPtr(label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size) + graph_size = graph_size or ImVec2(0,0) + values_offset = values_offset or 0 + scale_max = scale_max or M.FLT_MAX + scale_min = scale_min or M.FLT_MAX + overlay_text = overlay_text or nil + return lib.igPlotLinesFnPtr(label,values_getter,data,values_count,values_offset,overlay_text,scale_min,scale_max,graph_size) +end +M.PopAllowKeyboardFocus = lib.igPopAllowKeyboardFocus +M.PopButtonRepeat = lib.igPopButtonRepeat +M.PopClipRect = lib.igPopClipRect +M.PopFont = lib.igPopFont +M.PopID = lib.igPopID +M.PopItemWidth = lib.igPopItemWidth +function M.PopStyleColor(count) + count = count or 1 + return lib.igPopStyleColor(count) +end +function M.PopStyleVar(count) + count = count or 1 + return lib.igPopStyleVar(count) +end +M.PopTextWrapPos = lib.igPopTextWrapPos +function M.ProgressBar(fraction,size_arg,overlay) + overlay = overlay or nil + size_arg = size_arg or ImVec2(-1,0) + return lib.igProgressBar(fraction,size_arg,overlay) +end +M.PushAllowKeyboardFocus = lib.igPushAllowKeyboardFocus +M.PushButtonRepeat = lib.igPushButtonRepeat +M.PushClipRect = lib.igPushClipRect +M.PushFont = lib.igPushFont +M.PushIDStr = lib.igPushIDStr +M.PushIDRange = lib.igPushIDRange +M.PushIDPtr = lib.igPushIDPtr +M.PushIDInt = lib.igPushIDInt +M.PushItemWidth = lib.igPushItemWidth +M.PushStyleColorU32 = lib.igPushStyleColorU32 +M.PushStyleColor = lib.igPushStyleColor +M.PushStyleVarFloat = lib.igPushStyleVarFloat +M.PushStyleVarVec2 = lib.igPushStyleVarVec2 +function M.PushTextWrapPos(wrap_local_pos_x) + wrap_local_pos_x = wrap_local_pos_x or 0.0 + return lib.igPushTextWrapPos(wrap_local_pos_x) +end +M.RadioButtonBool = lib.igRadioButtonBool +M.RadioButtonIntPtr = lib.igRadioButtonIntPtr +M.Render = lib.igRender +function M.ResetMouseDragDelta(button) + button = button or 0 + return lib.igResetMouseDragDelta(button) +end +function M.SameLine(offset_from_start_x,spacing) + spacing = spacing or -1.0 + offset_from_start_x = offset_from_start_x or 0.0 + return lib.igSameLine(offset_from_start_x,spacing) +end +M.SaveIniSettingsToDisk = lib.igSaveIniSettingsToDisk +function M.SaveIniSettingsToMemory(out_ini_size) + out_ini_size = out_ini_size or nil + return lib.igSaveIniSettingsToMemory(out_ini_size) +end +function M.Selectable(label,selected,flags,size) + flags = flags or 0 + size = size or ImVec2(0,0) + selected = selected or false + return lib.igSelectable(label,selected,flags,size) +end +function M.SelectableBoolPtr(label,p_selected,flags,size) + size = size or ImVec2(0,0) + flags = flags or 0 + return lib.igSelectableBoolPtr(label,p_selected,flags,size) +end +M.Separator = lib.igSeparator +function M.SetAllocatorFunctions(alloc_func,free_func,user_data) + user_data = user_data or nil + return lib.igSetAllocatorFunctions(alloc_func,free_func,user_data) +end +M.SetClipboardText = lib.igSetClipboardText +M.SetColorEditOptions = lib.igSetColorEditOptions +M.SetColumnOffset = lib.igSetColumnOffset +M.SetColumnWidth = lib.igSetColumnWidth +M.SetCurrentContext = lib.igSetCurrentContext +M.SetCursorPos = lib.igSetCursorPos +M.SetCursorPosX = lib.igSetCursorPosX +M.SetCursorPosY = lib.igSetCursorPosY +M.SetCursorScreenPos = lib.igSetCursorScreenPos +function M.SetDragDropPayload(type,data,sz,cond) + cond = cond or 0 + return lib.igSetDragDropPayload(type,data,sz,cond) +end +M.SetItemAllowOverlap = lib.igSetItemAllowOverlap +M.SetItemDefaultFocus = lib.igSetItemDefaultFocus +function M.SetKeyboardFocusHere(offset) + offset = offset or 0 + return lib.igSetKeyboardFocusHere(offset) +end +M.SetMouseCursor = lib.igSetMouseCursor +function M.SetNextItemOpen(is_open,cond) + cond = cond or 0 + return lib.igSetNextItemOpen(is_open,cond) +end +M.SetNextItemWidth = lib.igSetNextItemWidth +M.SetNextWindowBgAlpha = lib.igSetNextWindowBgAlpha +function M.SetNextWindowCollapsed(collapsed,cond) + cond = cond or 0 + return lib.igSetNextWindowCollapsed(collapsed,cond) +end +M.SetNextWindowContentSize = lib.igSetNextWindowContentSize +M.SetNextWindowFocus = lib.igSetNextWindowFocus +function M.SetNextWindowPos(pos,cond,pivot) + cond = cond or 0 + pivot = pivot or ImVec2(0,0) + return lib.igSetNextWindowPos(pos,cond,pivot) +end +function M.SetNextWindowSize(size,cond) + cond = cond or 0 + return lib.igSetNextWindowSize(size,cond) +end +function M.SetNextWindowSizeConstraints(size_min,size_max,custom_callback,custom_callback_data) + custom_callback = custom_callback or nil + custom_callback_data = custom_callback_data or nil + return lib.igSetNextWindowSizeConstraints(size_min,size_max,custom_callback,custom_callback_data) +end +function M.SetScrollFromPosX(local_x,center_x_ratio) + center_x_ratio = center_x_ratio or 0.5 + return lib.igSetScrollFromPosX(local_x,center_x_ratio) +end +function M.SetScrollFromPosY(local_y,center_y_ratio) + center_y_ratio = center_y_ratio or 0.5 + return lib.igSetScrollFromPosY(local_y,center_y_ratio) +end +function M.SetScrollHereX(center_x_ratio) + center_x_ratio = center_x_ratio or 0.5 + return lib.igSetScrollHereX(center_x_ratio) +end +function M.SetScrollHereY(center_y_ratio) + center_y_ratio = center_y_ratio or 0.5 + return lib.igSetScrollHereY(center_y_ratio) +end +M.SetScrollX = lib.igSetScrollX +M.SetScrollY = lib.igSetScrollY +M.SetStateStorage = lib.igSetStateStorage +M.SetTabItemClosed = lib.igSetTabItemClosed +M.SetTooltip = lib.igSetTooltip +M.SetTooltipV = lib.igSetTooltipV +function M.SetWindowCollapsedBool(collapsed,cond) + cond = cond or 0 + return lib.igSetWindowCollapsedBool(collapsed,cond) +end +function M.SetWindowCollapsedStr(name,collapsed,cond) + cond = cond or 0 + return lib.igSetWindowCollapsedStr(name,collapsed,cond) +end +M.SetWindowFocus = lib.igSetWindowFocus +M.SetWindowFocusStr = lib.igSetWindowFocusStr +M.SetWindowFontScale = lib.igSetWindowFontScale +function M.SetWindowPosVec2(pos,cond) + cond = cond or 0 + return lib.igSetWindowPosVec2(pos,cond) +end +function M.SetWindowPosStr(name,pos,cond) + cond = cond or 0 + return lib.igSetWindowPosStr(name,pos,cond) +end +function M.SetWindowSizeVec2(size,cond) + cond = cond or 0 + return lib.igSetWindowSizeVec2(size,cond) +end +function M.SetWindowSizeStr(name,size,cond) + cond = cond or 0 + return lib.igSetWindowSizeStr(name,size,cond) +end +function M.ShowAboutWindow(p_open) + p_open = p_open or nil + return lib.igShowAboutWindow(p_open) +end +function M.ShowDemoWindow(p_open) + p_open = p_open or nil + return lib.igShowDemoWindow(p_open) +end +M.ShowFontSelector = lib.igShowFontSelector +function M.ShowMetricsWindow(p_open) + p_open = p_open or nil + return lib.igShowMetricsWindow(p_open) +end +function M.ShowStyleEditor(ref) + ref = ref or nil + return lib.igShowStyleEditor(ref) +end +M.ShowStyleSelector = lib.igShowStyleSelector +M.ShowUserGuide = lib.igShowUserGuide +function M.SliderAngle(label,v_rad,v_degrees_min,v_degrees_max,format) + v_degrees_min = v_degrees_min or -360.0 + v_degrees_max = v_degrees_max or 360.0 + format = format or "%.0f deg" + return lib.igSliderAngle(label,v_rad,v_degrees_min,v_degrees_max,format) +end +function M.SliderFloat(label,v,v_min,v_max,format,power) + power = power or 1.0 + format = format or "%.3f" + return lib.igSliderFloat(label,v,v_min,v_max,format,power) +end +function M.SliderFloat2(label,v,v_min,v_max,format,power) + power = power or 1.0 + format = format or "%.3f" + return lib.igSliderFloat2(label,v,v_min,v_max,format,power) +end +function M.SliderFloat3(label,v,v_min,v_max,format,power) + power = power or 1.0 + format = format or "%.3f" + return lib.igSliderFloat3(label,v,v_min,v_max,format,power) +end +function M.SliderFloat4(label,v,v_min,v_max,format,power) + power = power or 1.0 + format = format or "%.3f" + return lib.igSliderFloat4(label,v,v_min,v_max,format,power) +end +function M.SliderInt(label,v,v_min,v_max,format) + format = format or "%d" + return lib.igSliderInt(label,v,v_min,v_max,format) +end +function M.SliderInt2(label,v,v_min,v_max,format) + format = format or "%d" + return lib.igSliderInt2(label,v,v_min,v_max,format) +end +function M.SliderInt3(label,v,v_min,v_max,format) + format = format or "%d" + return lib.igSliderInt3(label,v,v_min,v_max,format) +end +function M.SliderInt4(label,v,v_min,v_max,format) + format = format or "%d" + return lib.igSliderInt4(label,v,v_min,v_max,format) +end +function M.SliderScalar(label,data_type,v,v_min,v_max,format,power) + power = power or 1.0 + format = format or nil + return lib.igSliderScalar(label,data_type,v,v_min,v_max,format,power) +end +function M.SliderScalarN(label,data_type,v,components,v_min,v_max,format,power) + power = power or 1.0 + format = format or nil + return lib.igSliderScalarN(label,data_type,v,components,v_min,v_max,format,power) +end +M.SmallButton = lib.igSmallButton +M.Spacing = lib.igSpacing +function M.StyleColorsClassic(dst) + dst = dst or nil + return lib.igStyleColorsClassic(dst) +end +function M.StyleColorsDark(dst) + dst = dst or nil + return lib.igStyleColorsDark(dst) +end +function M.StyleColorsLight(dst) + dst = dst or nil + return lib.igStyleColorsLight(dst) +end +M.Text = lib.igText +M.TextColored = lib.igTextColored +M.TextColoredV = lib.igTextColoredV +M.TextDisabled = lib.igTextDisabled +M.TextDisabledV = lib.igTextDisabledV +function M.TextUnformatted(text,text_end) + text_end = text_end or nil + return lib.igTextUnformatted(text,text_end) +end +M.TextV = lib.igTextV +M.TextWrapped = lib.igTextWrapped +M.TextWrappedV = lib.igTextWrappedV +M.TreeNodeStr = lib.igTreeNodeStr +M.TreeNodeStrStr = lib.igTreeNodeStrStr +M.TreeNodePtr = lib.igTreeNodePtr +function M.TreeNodeExStr(label,flags) + flags = flags or 0 + return lib.igTreeNodeExStr(label,flags) +end +M.TreeNodeExStrStr = lib.igTreeNodeExStrStr +M.TreeNodeExPtr = lib.igTreeNodeExPtr +M.TreeNodeExVStr = lib.igTreeNodeExVStr +M.TreeNodeExVPtr = lib.igTreeNodeExVPtr +M.TreeNodeVStr = lib.igTreeNodeVStr +M.TreeNodeVPtr = lib.igTreeNodeVPtr +M.TreePop = lib.igTreePop +M.TreePushStr = lib.igTreePushStr +function M.TreePushPtr(ptr_id) + ptr_id = ptr_id or nil + return lib.igTreePushPtr(ptr_id) +end +function M.Unindent(indent_w) + indent_w = indent_w or 0.0 + return lib.igUnindent(indent_w) +end +function M.VSliderFloat(label,size,v,v_min,v_max,format,power) + power = power or 1.0 + format = format or "%.3f" + return lib.igVSliderFloat(label,size,v,v_min,v_max,format,power) +end +function M.VSliderInt(label,size,v,v_min,v_max,format) + format = format or "%d" + return lib.igVSliderInt(label,size,v,v_min,v_max,format) +end +function M.VSliderScalar(label,size,data_type,v,v_min,v_max,format,power) + power = power or 1.0 + format = format or nil + return lib.igVSliderScalar(label,size,data_type,v,v_min,v_max,format,power) +end +M.ValueBool = lib.igValueBool +M.ValueInt = lib.igValueInt +M.ValueUint = lib.igValueUint +function M.ValueFloat(prefix,v,float_format) + float_format = float_format or nil + return lib.igValueFloat(prefix,v,float_format) +end +return M +----------END_AUTOGENERATED_LUA----------------------------- \ No newline at end of file diff --git a/mimgui/init.lua b/mimgui/init.lua new file mode 100644 index 0000000..4bf36fc --- /dev/null +++ b/mimgui/init.lua @@ -0,0 +1,368 @@ +-- This file is part of mimgui project +-- Licensed under the MIT License +-- Copyright (c) 2018, FYP + +assert(getMoonloaderVersion() >= 025) + +local imgui = require 'mimgui.imgui' +local DX9 = require 'mimgui.dx9' +local ffi = require 'ffi' +local winmsg = require 'windows.message' +local memory = require 'memory' +local mimgui = {} + +local renderer = nil +local subscriptionsInitialize = {} +local subscriptionsNewFrame = {} +local eventsRegistered = false +local active = false +local cursorActive = false +local playerLocked = false +local iniFilePath = nil +local defaultGlyphRanges = nil + +setmetatable(mimgui, {__index = imgui, __newindex = function(t, k, v) + if imgui[k] then + print('[mimgui] Warning! Overwriting existing key "'..k..'"!') + end + rawset(t, k, v) +end}) + +-- background "Shift" triggering fix +memory.fill(0x00531155, 0x90, 5, true) + +local function ShowCursor(show) + if show then + showCursor(true) + elseif cursorActive then + showCursor(false) + end + cursorActive = show +end + +local function LockPlayer(lock) + if lock then + lockPlayerControl(true) + elseif playerLocked then + lockPlayerControl(false) + end + playerLocked = lock +end + +-- MoonLoader v.027 +if not isCursorActive then + isCursorActive = function() return cursorActive end +end + +local function InitializeRenderer() + -- init renderer + local hwnd = ffi.cast('HWND', readMemory(0x00C8CF88, 4, false)) + local d3ddevice = ffi.cast('LPDIRECT3DDEVICE9', getD3DDevicePtr()) + renderer = assert(DX9.new(d3ddevice, hwnd)) + renderer:SwitchContext() + + -- configure imgui + imgui.GetIO().ImeWindowHandle = nil -- default causes crash. TODO: why? + imgui.GetIO().LogFilename = nil + local confdir = getWorkingDirectory() .. [[\config\mimgui\]] + if not doesDirectoryExist(confdir) then + createDirectory(confdir) + end + iniFilePath = ffi.new('char[260]', confdir .. script.this.filename .. '.ini') + imgui.GetIO().IniFilename = iniFilePath + + -- change font + local fontFile = getFolderPath(0x14) .. '\\trebucbd.ttf' + assert(doesFileExist(fontFile), '[mimgui] Font "' .. fontFile .. '" doesn\'t exist!') + local builder = imgui.ImFontGlyphRangesBuilder() + builder:AddRanges(imgui.GetIO().Fonts:GetGlyphRangesCyrillic()) + builder:AddText([[‚„…†‡€‰‹‘’“”•–—™›№]]) + defaultGlyphRanges = imgui.ImVector_ImWchar() + builder:BuildRanges(defaultGlyphRanges) + imgui.GetIO().Fonts:AddFontFromFileTTF(fontFile, 14, nil, defaultGlyphRanges[0].Data) + + -- invoke initializers + for _, cb in ipairs(subscriptionsInitialize) do + cb() + end +end + +local function RegisterEvents() + addEventHandler('onD3DPresent', function() + if active then + if not renderer then + InitializeRenderer() + end + if renderer and not renderer.lost then + renderer:SwitchContext() + for _, sub in ipairs(subscriptionsNewFrame) do + if sub._render and sub._before then + sub:_before() + end + end + renderer:NewFrame() + local hideCursor = true + for _, sub in ipairs(subscriptionsNewFrame) do + if sub._render then + sub:_draw() + hideCursor = hideCursor and sub.HideCursor + end + end + if hideCursor and not isCursorActive() then + imgui.SetMouseCursor(imgui.lib.ImGuiMouseCursor_None) + end + renderer:EndFrame() + end + end + end) + + local keyState = {} + local WM_MOUSEHWHEEL = 0x020E + local mouseMsgs = { + [WM_MOUSEHWHEEL]=true, + [winmsg.WM_LBUTTONDOWN]=true, + [winmsg.WM_LBUTTONDBLCLK]=true, + [winmsg.WM_RBUTTONDOWN]=true, + [winmsg.WM_RBUTTONDBLCLK]=true, + [winmsg.WM_MBUTTONDOWN]=true, + [winmsg.WM_MBUTTONDBLCLK]=true, + [winmsg.WM_LBUTTONUP]=true, + [winmsg.WM_RBUTTONUP]=true, + [winmsg.WM_MBUTTONUP]=true, + [winmsg.WM_MOUSEWHEEL]=true, + [winmsg.WM_SETCURSOR]=true + } + local keyboardMsgs = { + [winmsg.WM_KEYDOWN]=true, + [winmsg.WM_SYSKEYDOWN]=true, + [winmsg.WM_KEYUP]=true, + [winmsg.WM_SYSKEYUP]=true, + [winmsg.WM_CHAR]=true + } + addEventHandler('onWindowMessage', function(msg, wparam, lparam) + if not renderer then + return + end + + if not mimgui.DisableInput then + local keyboard = keyboardMsgs[msg] + local mouse = mouseMsgs[msg] + if active and (keyboard or mouse) then + renderer:SwitchContext() + local io = imgui.GetIO() + renderer:WindowMessage(msg, wparam, lparam) + if (keyboard and io.WantCaptureKeyboard) or (mouse and io.WantCaptureMouse) then + if msg == winmsg.WM_KEYDOWN or msg == winmsg.WM_SYSKEYDOWN then + keyState[wparam] = false + consumeWindowMessage(true, true, true) + elseif msg == winmsg.WM_KEYUP or msg == winmsg.WM_SYSKEYUP then + if not keyState[wparam] then + consumeWindowMessage(true, true, true) + end + else + consumeWindowMessage(true, true, true) + end + end + end + end + + -- save key states to prevent key sticking + if msg == winmsg.WM_KILLFOCUS then + keyState = {} + elseif wparam < 256 then + if msg == winmsg.WM_KEYDOWN or msg == winmsg.WM_SYSKEYDOWN then + keyState[wparam] = true + elseif msg == winmsg.WM_KEYUP or msg == winmsg.WM_SYSKEYUP then + keyState[wparam] = false + end + end + end) + + addEventHandler('onD3DDeviceLost', function() + if renderer and not renderer.lost then + renderer:InvalidateDeviceObjects() + renderer.lost = true + end + end) + + addEventHandler('onD3DDeviceReset', function() + if renderer then + renderer.lost = false + end + end) + + addEventHandler('onScriptTerminate', function(scr) + if scr == script.this then + ShowCursor(false) + LockPlayer(false) + end + end) + + local updaterThread = lua_thread.create(function() + while true do + wait(0) + local activate, hideCursor, lockPlayer = false, true, false + if #subscriptionsNewFrame > 0 then + for i, sub in ipairs(subscriptionsNewFrame) do + if type(sub.Condition) == 'function' then + sub._render = sub.Condition() + else + sub._render = sub.Condition and true + end + if sub._render then + hideCursor = hideCursor and sub.HideCursor + lockPlayer = lockPlayer or sub.LockPlayer + end + activate = activate or sub._render + end + end + active = activate + ShowCursor(active and not hideCursor) + LockPlayer(active and lockPlayer) + end + end) + updaterThread.work_in_pause = true +end + +local function Unsubscribe(t, sub) + for i, v in ipairs(t) do + if v == sub then + table.remove(t, i) + return + end + end +end + +local function ImGuiEnum(name) + return setmetatable({__name = name}, {__index = function(t, k) + return imgui.lib[t.__name .. k] + end}) +end + +--- API --- +mimgui._VERSION = '1.7.0' +mimgui.DisableInput = false + +mimgui.ComboFlags = ImGuiEnum('ImGuiComboFlags_') +mimgui.Dir = ImGuiEnum('ImGuiDir_') +mimgui.ColorEditFlags = ImGuiEnum('ImGuiColorEditFlags_') +mimgui.Col = ImGuiEnum('ImGuiCol_') +mimgui.WindowFlags = ImGuiEnum('ImGuiWindowFlags_') +mimgui.NavInput = ImGuiEnum('ImGuiNavInput_') +mimgui.FocusedFlags = ImGuiEnum('ImGuiFocusedFlags_') +mimgui.Cond = ImGuiEnum('ImGuiCond_') +mimgui.BackendFlags = ImGuiEnum('ImGuiBackendFlags_') +mimgui.TreeNodeFlags = ImGuiEnum('ImGuiTreeNodeFlags_') +mimgui.StyleVar = ImGuiEnum('ImGuiStyleVar_') +mimgui.DrawCornerFlags = ImGuiEnum('ImDrawCornerFlags_') +mimgui.DragDropFlags = ImGuiEnum('ImGuiDragDropFlags_') +mimgui.SelectableFlags = ImGuiEnum('ImGuiSelectableFlags_') +mimgui.InputTextFlags = ImGuiEnum('ImGuiInputTextFlags_') +mimgui.MouseCursor = ImGuiEnum('ImGuiMouseCursor_') +mimgui.FontAtlasFlags = ImGuiEnum('ImFontAtlasFlags_') +mimgui.HoveredFlags = ImGuiEnum('ImGuiHoveredFlags_') +mimgui.ConfigFlags = ImGuiEnum('ImGuiConfigFlags_') +mimgui.DrawListFlags = ImGuiEnum('ImDrawListFlags_') +mimgui.DataType = ImGuiEnum('ImGuiDataType_') +mimgui.Key = ImGuiEnum('ImGuiKey_') + +function mimgui.OnInitialize(cb) + assert(type(cb) == 'function') + table.insert(subscriptionsInitialize, cb) + return {Unsubscribe = function() Unsubscribe(subscriptionsInitialize, cb) end} +end + +function mimgui.OnFrame(cond, cbBeforeFrame, cbDraw) + assert(type(cond) == 'function') + assert(type(cbBeforeFrame) == 'function') + if cbDraw then assert(type(cbDraw) == 'function') end + if not eventsRegistered then + RegisterEvents() + eventsRegistered = true + end + local sub = { + Condition = cond, + LockPlayer = false, + HideCursor = false, + _before = cbDraw and cbBeforeFrame or nil, + _draw = cbDraw or cbBeforeFrame, + _render = false, + } + function sub:Unsubscribe() + Unsubscribe(subscriptionsNewFrame, self) + end + function sub:IsActive() + return self._render + end + table.insert(subscriptionsNewFrame, sub) + return sub +end + +function mimgui.SwitchContext() + return renderer:SwitchContext() +end + +function mimgui.CreateTextureFromFile(path) + return renderer:CreateTextureFromFile(path) +end + +function mimgui.CreateTextureFromFileInMemory(src, size) + return renderer:CreateTextureFromFileInMemory(src, size) +end + +function mimgui.ReleaseTexture(tex) + return renderer:ReleaseTexture(tex) +end + +function mimgui.CreateFontsTexture() + return renderer:CreateFontsTexture() +end + +function mimgui.InvalidateFontsTexture() + return renderer:InvalidateFontsTexture() +end + +function mimgui.GetRenderer() + return renderer +end + +function mimgui.IsInitialized() + return renderer ~= nil +end + +function mimgui.StrCopy(dst, src, len) + if len or tostring(ffi.typeof(dst)):find('*', 1, true) then + ffi.copy(dst, src, len) + else + len = math.min(ffi.sizeof(dst) - 1, #src) + ffi.copy(dst, src, len) + dst[len] = 0 + end +end + +local new = {} +setmetatable(new, { + __index = function(self, key) + local basetype = ffi.typeof(key) + local mt = { + __index = function(self, sz) + return setmetatable({type = ffi.typeof('$[$]', self.type, sz)}, getmetatable(self)) + end, + __call = function(self, ...) + return self.type(...) + end + } + return setmetatable({type = ffi.typeof('$[1]', basetype), basetype = basetype}, { + __index = function(self, sz) + return setmetatable({type = ffi.typeof('$[$]', self.basetype, sz)}, mt) + end, + __call = mt.__call + }) + end, + __call = function(self, t, ...) + return ffi.new(t, ...) + end +}) +mimgui.new = new + +return mimgui