using System;
using System.Diagnostics;
using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[assembly: InternalsVisibleTo("ImPlot.NET")]
[assembly: InternalsVisibleTo("ImNodes.NET")]
[assembly: AssemblyCompany("Eric Mellino")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("A .NET wrapper for the Dear ImGui library.")]
[assembly: AssemblyFileVersion("1.89.1")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("ImGui.NET")]
[assembly: AssemblyTitle("ImGui.NET")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.89.1.0")]
[module: UnverifiableCode]
namespace ImGuiNET;

public struct ImColor
{
	public Vector4 Value;
}
public struct ImColorPtr
{
	public unsafe ImColor* NativePtr { get; }

	public unsafe ref Vector4 Value => ref Unsafe.AsRef<Vector4>(&NativePtr->Value);

	public unsafe ImColorPtr(ImColor* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImColorPtr(IntPtr nativePtr)
	{
		NativePtr = (ImColor*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImColorPtr(ImColor* nativePtr)
	{
		return new ImColorPtr(nativePtr);
	}

	public unsafe static implicit operator ImColor*(ImColorPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImColorPtr(IntPtr nativePtr)
	{
		return new ImColorPtr(nativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImColor_destroy(NativePtr);
	}

	public unsafe ImColor HSV(float h, float s, float v)
	{
		float a = 1f;
		ImColor result = default(ImColor);
		ImGuiNative.ImColor_HSV(&result, h, s, v, a);
		return result;
	}

	public unsafe ImColor HSV(float h, float s, float v, float a)
	{
		ImColor result = default(ImColor);
		ImGuiNative.ImColor_HSV(&result, h, s, v, a);
		return result;
	}

	public unsafe void SetHSV(float h, float s, float v)
	{
		float a = 1f;
		ImGuiNative.ImColor_SetHSV(NativePtr, h, s, v, a);
	}

	public unsafe void SetHSV(float h, float s, float v, float a)
	{
		ImGuiNative.ImColor_SetHSV(NativePtr, h, s, v, a);
	}
}
public struct ImDrawChannel
{
	public ImVector _CmdBuffer;

	public ImVector _IdxBuffer;
}
public struct ImDrawChannelPtr
{
	public unsafe ImDrawChannel* NativePtr { get; }

	public unsafe ImPtrVector<ImDrawCmdPtr> _CmdBuffer => new ImPtrVector<ImDrawCmdPtr>(NativePtr->_CmdBuffer, Unsafe.SizeOf<ImDrawCmd>());

	public unsafe ImVector<ushort> _IdxBuffer => new ImVector<ushort>(NativePtr->_IdxBuffer);

	public unsafe ImDrawChannelPtr(ImDrawChannel* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImDrawChannelPtr(IntPtr nativePtr)
	{
		NativePtr = (ImDrawChannel*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImDrawChannelPtr(ImDrawChannel* nativePtr)
	{
		return new ImDrawChannelPtr(nativePtr);
	}

	public unsafe static implicit operator ImDrawChannel*(ImDrawChannelPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImDrawChannelPtr(IntPtr nativePtr)
	{
		return new ImDrawChannelPtr(nativePtr);
	}
}
public struct ImDrawCmd
{
	public Vector4 ClipRect;

	public IntPtr TextureId;

	public uint VtxOffset;

	public uint IdxOffset;

	public uint ElemCount;

	public IntPtr UserCallback;

	public unsafe void* UserCallbackData;
}
public struct ImDrawCmdPtr
{
	public unsafe ImDrawCmd* NativePtr { get; }

	public unsafe ref Vector4 ClipRect => ref Unsafe.AsRef<Vector4>(&NativePtr->ClipRect);

	public unsafe ref IntPtr TextureId => ref Unsafe.AsRef<IntPtr>(&NativePtr->TextureId);

	public unsafe ref uint VtxOffset => ref Unsafe.AsRef<uint>(&NativePtr->VtxOffset);

	public unsafe ref uint IdxOffset => ref Unsafe.AsRef<uint>(&NativePtr->IdxOffset);

	public unsafe ref uint ElemCount => ref Unsafe.AsRef<uint>(&NativePtr->ElemCount);

	public unsafe ref IntPtr UserCallback => ref Unsafe.AsRef<IntPtr>(&NativePtr->UserCallback);

	public unsafe IntPtr UserCallbackData
	{
		get
		{
			return (IntPtr)NativePtr->UserCallbackData;
		}
		set
		{
			NativePtr->UserCallbackData = (void*)value;
		}
	}

	public unsafe ImDrawCmdPtr(ImDrawCmd* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImDrawCmdPtr(IntPtr nativePtr)
	{
		NativePtr = (ImDrawCmd*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImDrawCmdPtr(ImDrawCmd* nativePtr)
	{
		return new ImDrawCmdPtr(nativePtr);
	}

	public unsafe static implicit operator ImDrawCmd*(ImDrawCmdPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImDrawCmdPtr(IntPtr nativePtr)
	{
		return new ImDrawCmdPtr(nativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImDrawCmd_destroy(NativePtr);
	}

	public unsafe IntPtr GetTexID()
	{
		return ImGuiNative.ImDrawCmd_GetTexID(NativePtr);
	}
}
public struct ImDrawCmdHeader
{
	public Vector4 ClipRect;

	public IntPtr TextureId;

	public uint VtxOffset;
}
public struct ImDrawCmdHeaderPtr
{
	public unsafe ImDrawCmdHeader* NativePtr { get; }

	public unsafe ref Vector4 ClipRect => ref Unsafe.AsRef<Vector4>(&NativePtr->ClipRect);

	public unsafe ref IntPtr TextureId => ref Unsafe.AsRef<IntPtr>(&NativePtr->TextureId);

	public unsafe ref uint VtxOffset => ref Unsafe.AsRef<uint>(&NativePtr->VtxOffset);

	public unsafe ImDrawCmdHeaderPtr(ImDrawCmdHeader* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImDrawCmdHeaderPtr(IntPtr nativePtr)
	{
		NativePtr = (ImDrawCmdHeader*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImDrawCmdHeaderPtr(ImDrawCmdHeader* nativePtr)
	{
		return new ImDrawCmdHeaderPtr(nativePtr);
	}

	public unsafe static implicit operator ImDrawCmdHeader*(ImDrawCmdHeaderPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImDrawCmdHeaderPtr(IntPtr nativePtr)
	{
		return new ImDrawCmdHeaderPtr(nativePtr);
	}
}
public struct ImDrawData
{
	public byte Valid;

	public int CmdListsCount;

	public int TotalIdxCount;

	public int TotalVtxCount;

	public unsafe ImDrawList** CmdLists;

	public Vector2 DisplayPos;

	public Vector2 DisplaySize;

	public Vector2 FramebufferScale;

	public unsafe ImGuiViewport* OwnerViewport;
}
public struct ImDrawDataPtr
{
	public unsafe ImDrawData* NativePtr { get; }

	public unsafe ref bool Valid => ref Unsafe.AsRef<bool>(&NativePtr->Valid);

	public unsafe ref int CmdListsCount => ref Unsafe.AsRef<int>(&NativePtr->CmdListsCount);

	public unsafe ref int TotalIdxCount => ref Unsafe.AsRef<int>(&NativePtr->TotalIdxCount);

	public unsafe ref int TotalVtxCount => ref Unsafe.AsRef<int>(&NativePtr->TotalVtxCount);

	public unsafe IntPtr CmdLists
	{
		get
		{
			return (IntPtr)NativePtr->CmdLists;
		}
		set
		{
			NativePtr->CmdLists = (ImDrawList**)(void*)value;
		}
	}

	public unsafe ref Vector2 DisplayPos => ref Unsafe.AsRef<Vector2>(&NativePtr->DisplayPos);

	public unsafe ref Vector2 DisplaySize => ref Unsafe.AsRef<Vector2>(&NativePtr->DisplaySize);

	public unsafe ref Vector2 FramebufferScale => ref Unsafe.AsRef<Vector2>(&NativePtr->FramebufferScale);

	public unsafe ImGuiViewportPtr OwnerViewport => new ImGuiViewportPtr(NativePtr->OwnerViewport);

	public unsafe RangePtrAccessor<ImDrawListPtr> CmdListsRange => new RangePtrAccessor<ImDrawListPtr>(CmdLists.ToPointer(), CmdListsCount);

	public unsafe ImDrawDataPtr(ImDrawData* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImDrawDataPtr(IntPtr nativePtr)
	{
		NativePtr = (ImDrawData*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImDrawDataPtr(ImDrawData* nativePtr)
	{
		return new ImDrawDataPtr(nativePtr);
	}

	public unsafe static implicit operator ImDrawData*(ImDrawDataPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImDrawDataPtr(IntPtr nativePtr)
	{
		return new ImDrawDataPtr(nativePtr);
	}

	public unsafe void Clear()
	{
		ImGuiNative.ImDrawData_Clear(NativePtr);
	}

	public unsafe void DeIndexAllBuffers()
	{
		ImGuiNative.ImDrawData_DeIndexAllBuffers(NativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImDrawData_destroy(NativePtr);
	}

	public unsafe void ScaleClipRects(Vector2 fb_scale)
	{
		ImGuiNative.ImDrawData_ScaleClipRects(NativePtr, fb_scale);
	}
}
[Flags]
public enum ImDrawFlags
{
	None = 0,
	Closed = 1,
	RoundCornersTopLeft = 0x10,
	RoundCornersTopRight = 0x20,
	RoundCornersBottomLeft = 0x40,
	RoundCornersBottomRight = 0x80,
	RoundCornersNone = 0x100,
	RoundCornersTop = 0x30,
	RoundCornersBottom = 0xC0,
	RoundCornersLeft = 0x50,
	RoundCornersRight = 0xA0,
	RoundCornersAll = 0xF0,
	RoundCornersDefault = 0xF0,
	RoundCornersMask = 0x1F0
}
public struct ImDrawList
{
	public ImVector CmdBuffer;

	public ImVector IdxBuffer;

	public ImVector VtxBuffer;

	public ImDrawListFlags Flags;

	public uint _VtxCurrentIdx;

	public IntPtr _Data;

	public unsafe byte* _OwnerName;

	public unsafe ImDrawVert* _VtxWritePtr;

	public unsafe ushort* _IdxWritePtr;

	public ImVector _ClipRectStack;

	public ImVector _TextureIdStack;

	public ImVector _Path;

	public ImDrawCmdHeader _CmdHeader;

	public ImDrawListSplitter _Splitter;

	public float _FringeScale;
}
public struct ImDrawListPtr
{
	public unsafe ImDrawList* NativePtr { get; }

	public unsafe ImPtrVector<ImDrawCmdPtr> CmdBuffer => new ImPtrVector<ImDrawCmdPtr>(NativePtr->CmdBuffer, Unsafe.SizeOf<ImDrawCmd>());

	public unsafe ImVector<ushort> IdxBuffer => new ImVector<ushort>(NativePtr->IdxBuffer);

	public unsafe ImPtrVector<ImDrawVertPtr> VtxBuffer => new ImPtrVector<ImDrawVertPtr>(NativePtr->VtxBuffer, Unsafe.SizeOf<ImDrawVert>());

	public unsafe ref ImDrawListFlags Flags => ref Unsafe.AsRef<ImDrawListFlags>(&NativePtr->Flags);

	public unsafe ref uint _VtxCurrentIdx => ref Unsafe.AsRef<uint>(&NativePtr->_VtxCurrentIdx);

	public unsafe ref IntPtr _Data => ref Unsafe.AsRef<IntPtr>(&NativePtr->_Data);

	public unsafe NullTerminatedString _OwnerName => new NullTerminatedString(NativePtr->_OwnerName);

	public unsafe ImDrawVertPtr _VtxWritePtr => new ImDrawVertPtr(NativePtr->_VtxWritePtr);

	public unsafe IntPtr _IdxWritePtr
	{
		get
		{
			return (IntPtr)NativePtr->_IdxWritePtr;
		}
		set
		{
			NativePtr->_IdxWritePtr = (ushort*)(void*)value;
		}
	}

	public unsafe ImVector<Vector4> _ClipRectStack => new ImVector<Vector4>(NativePtr->_ClipRectStack);

	public unsafe ImVector<IntPtr> _TextureIdStack => new ImVector<IntPtr>(NativePtr->_TextureIdStack);

	public unsafe ImVector<Vector2> _Path => new ImVector<Vector2>(NativePtr->_Path);

	public unsafe ref ImDrawCmdHeader _CmdHeader => ref Unsafe.AsRef<ImDrawCmdHeader>(&NativePtr->_CmdHeader);

	public unsafe ref ImDrawListSplitter _Splitter => ref Unsafe.AsRef<ImDrawListSplitter>(&NativePtr->_Splitter);

	public unsafe ref float _FringeScale => ref Unsafe.AsRef<float>(&NativePtr->_FringeScale);

	public unsafe ImDrawListPtr(ImDrawList* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImDrawListPtr(IntPtr nativePtr)
	{
		NativePtr = (ImDrawList*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImDrawListPtr(ImDrawList* nativePtr)
	{
		return new ImDrawListPtr(nativePtr);
	}

	public unsafe static implicit operator ImDrawList*(ImDrawListPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImDrawListPtr(IntPtr nativePtr)
	{
		return new ImDrawListPtr(nativePtr);
	}

	public unsafe int _CalcCircleAutoSegmentCount(float radius)
	{
		return ImGuiNative.ImDrawList__CalcCircleAutoSegmentCount(NativePtr, radius);
	}

	public unsafe void _ClearFreeMemory()
	{
		ImGuiNative.ImDrawList__ClearFreeMemory(NativePtr);
	}

	public unsafe void _OnChangedClipRect()
	{
		ImGuiNative.ImDrawList__OnChangedClipRect(NativePtr);
	}

	public unsafe void _OnChangedTextureID()
	{
		ImGuiNative.ImDrawList__OnChangedTextureID(NativePtr);
	}

	public unsafe void _OnChangedVtxOffset()
	{
		ImGuiNative.ImDrawList__OnChangedVtxOffset(NativePtr);
	}

	public unsafe void _PathArcToFastEx(Vector2 center, float radius, int a_min_sample, int a_max_sample, int a_step)
	{
		ImGuiNative.ImDrawList__PathArcToFastEx(NativePtr, center, radius, a_min_sample, a_max_sample, a_step);
	}

	public unsafe void _PathArcToN(Vector2 center, float radius, float a_min, float a_max, int num_segments)
	{
		ImGuiNative.ImDrawList__PathArcToN(NativePtr, center, radius, a_min, a_max, num_segments);
	}

	public unsafe void _PopUnusedDrawCmd()
	{
		ImGuiNative.ImDrawList__PopUnusedDrawCmd(NativePtr);
	}

	public unsafe void _ResetForNewFrame()
	{
		ImGuiNative.ImDrawList__ResetForNewFrame(NativePtr);
	}

	public unsafe void _TryMergeDrawCmds()
	{
		ImGuiNative.ImDrawList__TryMergeDrawCmds(NativePtr);
	}

	public unsafe void AddBezierCubic(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col, float thickness)
	{
		int num_segments = 0;
		ImGuiNative.ImDrawList_AddBezierCubic(NativePtr, p1, p2, p3, p4, col, thickness, num_segments);
	}

	public unsafe void AddBezierCubic(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col, float thickness, int num_segments)
	{
		ImGuiNative.ImDrawList_AddBezierCubic(NativePtr, p1, p2, p3, p4, col, thickness, num_segments);
	}

	public unsafe void AddBezierQuadratic(Vector2 p1, Vector2 p2, Vector2 p3, uint col, float thickness)
	{
		int num_segments = 0;
		ImGuiNative.ImDrawList_AddBezierQuadratic(NativePtr, p1, p2, p3, col, thickness, num_segments);
	}

	public unsafe void AddBezierQuadratic(Vector2 p1, Vector2 p2, Vector2 p3, uint col, float thickness, int num_segments)
	{
		ImGuiNative.ImDrawList_AddBezierQuadratic(NativePtr, p1, p2, p3, col, thickness, num_segments);
	}

	public unsafe void AddCallback(IntPtr callback, IntPtr callback_data)
	{
		void* callback_data2 = callback_data.ToPointer();
		ImGuiNative.ImDrawList_AddCallback(NativePtr, callback, callback_data2);
	}

	public unsafe void AddCircle(Vector2 center, float radius, uint col)
	{
		int num_segments = 0;
		float thickness = 1f;
		ImGuiNative.ImDrawList_AddCircle(NativePtr, center, radius, col, num_segments, thickness);
	}

	public unsafe void AddCircle(Vector2 center, float radius, uint col, int num_segments)
	{
		float thickness = 1f;
		ImGuiNative.ImDrawList_AddCircle(NativePtr, center, radius, col, num_segments, thickness);
	}

	public unsafe void AddCircle(Vector2 center, float radius, uint col, int num_segments, float thickness)
	{
		ImGuiNative.ImDrawList_AddCircle(NativePtr, center, radius, col, num_segments, thickness);
	}

	public unsafe void AddCircleFilled(Vector2 center, float radius, uint col)
	{
		int num_segments = 0;
		ImGuiNative.ImDrawList_AddCircleFilled(NativePtr, center, radius, col, num_segments);
	}

	public unsafe void AddCircleFilled(Vector2 center, float radius, uint col, int num_segments)
	{
		ImGuiNative.ImDrawList_AddCircleFilled(NativePtr, center, radius, col, num_segments);
	}

	public unsafe void AddConvexPolyFilled(ref Vector2 points, int num_points, uint col)
	{
		fixed (Vector2* points2 = &points)
		{
			ImGuiNative.ImDrawList_AddConvexPolyFilled(NativePtr, points2, num_points, col);
		}
	}

	public unsafe void AddDrawCmd()
	{
		ImGuiNative.ImDrawList_AddDrawCmd(NativePtr);
	}

	public unsafe void AddImage(IntPtr user_texture_id, Vector2 p_min, Vector2 p_max)
	{
		Vector2 uv_min = default(Vector2);
		Vector2 uv_max = new Vector2(1f, 1f);
		uint col = uint.MaxValue;
		ImGuiNative.ImDrawList_AddImage(NativePtr, user_texture_id, p_min, p_max, uv_min, uv_max, col);
	}

	public unsafe void AddImage(IntPtr user_texture_id, Vector2 p_min, Vector2 p_max, Vector2 uv_min)
	{
		Vector2 uv_max = new Vector2(1f, 1f);
		uint col = uint.MaxValue;
		ImGuiNative.ImDrawList_AddImage(NativePtr, user_texture_id, p_min, p_max, uv_min, uv_max, col);
	}

	public unsafe void AddImage(IntPtr user_texture_id, Vector2 p_min, Vector2 p_max, Vector2 uv_min, Vector2 uv_max)
	{
		uint col = uint.MaxValue;
		ImGuiNative.ImDrawList_AddImage(NativePtr, user_texture_id, p_min, p_max, uv_min, uv_max, col);
	}

	public unsafe void AddImage(IntPtr user_texture_id, Vector2 p_min, Vector2 p_max, Vector2 uv_min, Vector2 uv_max, uint col)
	{
		ImGuiNative.ImDrawList_AddImage(NativePtr, user_texture_id, p_min, p_max, uv_min, uv_max, col);
	}

	public unsafe void AddImageQuad(IntPtr user_texture_id, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4)
	{
		Vector2 uv = default(Vector2);
		Vector2 uv2 = new Vector2(1f, 0f);
		Vector2 uv3 = new Vector2(1f, 1f);
		Vector2 uv4 = new Vector2(0f, 1f);
		uint col = uint.MaxValue;
		ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, p1, p2, p3, p4, uv, uv2, uv3, uv4, col);
	}

	public unsafe void AddImageQuad(IntPtr user_texture_id, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 uv1)
	{
		Vector2 uv2 = new Vector2(1f, 0f);
		Vector2 uv3 = new Vector2(1f, 1f);
		Vector2 uv4 = new Vector2(0f, 1f);
		uint col = uint.MaxValue;
		ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, p1, p2, p3, p4, uv1, uv2, uv3, uv4, col);
	}

	public unsafe void AddImageQuad(IntPtr user_texture_id, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 uv1, Vector2 uv2)
	{
		Vector2 uv3 = new Vector2(1f, 1f);
		Vector2 uv4 = new Vector2(0f, 1f);
		uint col = uint.MaxValue;
		ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, p1, p2, p3, p4, uv1, uv2, uv3, uv4, col);
	}

	public unsafe void AddImageQuad(IntPtr user_texture_id, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 uv1, Vector2 uv2, Vector2 uv3)
	{
		Vector2 uv4 = new Vector2(0f, 1f);
		uint col = uint.MaxValue;
		ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, p1, p2, p3, p4, uv1, uv2, uv3, uv4, col);
	}

	public unsafe void AddImageQuad(IntPtr user_texture_id, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 uv1, Vector2 uv2, Vector2 uv3, Vector2 uv4)
	{
		uint col = uint.MaxValue;
		ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, p1, p2, p3, p4, uv1, uv2, uv3, uv4, col);
	}

	public unsafe void AddImageQuad(IntPtr user_texture_id, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 uv1, Vector2 uv2, Vector2 uv3, Vector2 uv4, uint col)
	{
		ImGuiNative.ImDrawList_AddImageQuad(NativePtr, user_texture_id, p1, p2, p3, p4, uv1, uv2, uv3, uv4, col);
	}

	public unsafe void AddImageRounded(IntPtr user_texture_id, Vector2 p_min, Vector2 p_max, Vector2 uv_min, Vector2 uv_max, uint col, float rounding)
	{
		ImDrawFlags flags = ImDrawFlags.None;
		ImGuiNative.ImDrawList_AddImageRounded(NativePtr, user_texture_id, p_min, p_max, uv_min, uv_max, col, rounding, flags);
	}

	public unsafe void AddImageRounded(IntPtr user_texture_id, Vector2 p_min, Vector2 p_max, Vector2 uv_min, Vector2 uv_max, uint col, float rounding, ImDrawFlags flags)
	{
		ImGuiNative.ImDrawList_AddImageRounded(NativePtr, user_texture_id, p_min, p_max, uv_min, uv_max, col, rounding, flags);
	}

	public unsafe void AddLine(Vector2 p1, Vector2 p2, uint col)
	{
		float thickness = 1f;
		ImGuiNative.ImDrawList_AddLine(NativePtr, p1, p2, col, thickness);
	}

	public unsafe void AddLine(Vector2 p1, Vector2 p2, uint col, float thickness)
	{
		ImGuiNative.ImDrawList_AddLine(NativePtr, p1, p2, col, thickness);
	}

	public unsafe void AddNgon(Vector2 center, float radius, uint col, int num_segments)
	{
		float thickness = 1f;
		ImGuiNative.ImDrawList_AddNgon(NativePtr, center, radius, col, num_segments, thickness);
	}

	public unsafe void AddNgon(Vector2 center, float radius, uint col, int num_segments, float thickness)
	{
		ImGuiNative.ImDrawList_AddNgon(NativePtr, center, radius, col, num_segments, thickness);
	}

	public unsafe void AddNgonFilled(Vector2 center, float radius, uint col, int num_segments)
	{
		ImGuiNative.ImDrawList_AddNgonFilled(NativePtr, center, radius, col, num_segments);
	}

	public unsafe void AddPolyline(ref Vector2 points, int num_points, uint col, ImDrawFlags flags, float thickness)
	{
		fixed (Vector2* points2 = &points)
		{
			ImGuiNative.ImDrawList_AddPolyline(NativePtr, points2, num_points, col, flags, thickness);
		}
	}

	public unsafe void AddQuad(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col)
	{
		float thickness = 1f;
		ImGuiNative.ImDrawList_AddQuad(NativePtr, p1, p2, p3, p4, col, thickness);
	}

	public unsafe void AddQuad(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col, float thickness)
	{
		ImGuiNative.ImDrawList_AddQuad(NativePtr, p1, p2, p3, p4, col, thickness);
	}

	public unsafe void AddQuadFilled(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col)
	{
		ImGuiNative.ImDrawList_AddQuadFilled(NativePtr, p1, p2, p3, p4, col);
	}

	public unsafe void AddRect(Vector2 p_min, Vector2 p_max, uint col)
	{
		float rounding = 0f;
		ImDrawFlags flags = ImDrawFlags.None;
		float thickness = 1f;
		ImGuiNative.ImDrawList_AddRect(NativePtr, p_min, p_max, col, rounding, flags, thickness);
	}

	public unsafe void AddRect(Vector2 p_min, Vector2 p_max, uint col, float rounding)
	{
		ImDrawFlags flags = ImDrawFlags.None;
		float thickness = 1f;
		ImGuiNative.ImDrawList_AddRect(NativePtr, p_min, p_max, col, rounding, flags, thickness);
	}

	public unsafe void AddRect(Vector2 p_min, Vector2 p_max, uint col, float rounding, ImDrawFlags flags)
	{
		float thickness = 1f;
		ImGuiNative.ImDrawList_AddRect(NativePtr, p_min, p_max, col, rounding, flags, thickness);
	}

	public unsafe void AddRect(Vector2 p_min, Vector2 p_max, uint col, float rounding, ImDrawFlags flags, float thickness)
	{
		ImGuiNative.ImDrawList_AddRect(NativePtr, p_min, p_max, col, rounding, flags, thickness);
	}

	public unsafe void AddRectFilled(Vector2 p_min, Vector2 p_max, uint col)
	{
		float rounding = 0f;
		ImDrawFlags flags = ImDrawFlags.None;
		ImGuiNative.ImDrawList_AddRectFilled(NativePtr, p_min, p_max, col, rounding, flags);
	}

	public unsafe void AddRectFilled(Vector2 p_min, Vector2 p_max, uint col, float rounding)
	{
		ImDrawFlags flags = ImDrawFlags.None;
		ImGuiNative.ImDrawList_AddRectFilled(NativePtr, p_min, p_max, col, rounding, flags);
	}

	public unsafe void AddRectFilled(Vector2 p_min, Vector2 p_max, uint col, float rounding, ImDrawFlags flags)
	{
		ImGuiNative.ImDrawList_AddRectFilled(NativePtr, p_min, p_max, col, rounding, flags);
	}

	public unsafe void AddRectFilledMultiColor(Vector2 p_min, Vector2 p_max, uint col_upr_left, uint col_upr_right, uint col_bot_right, uint col_bot_left)
	{
		ImGuiNative.ImDrawList_AddRectFilledMultiColor(NativePtr, p_min, p_max, col_upr_left, col_upr_right, col_bot_right, col_bot_left);
	}

	public unsafe void AddTriangle(Vector2 p1, Vector2 p2, Vector2 p3, uint col)
	{
		float thickness = 1f;
		ImGuiNative.ImDrawList_AddTriangle(NativePtr, p1, p2, p3, col, thickness);
	}

	public unsafe void AddTriangle(Vector2 p1, Vector2 p2, Vector2 p3, uint col, float thickness)
	{
		ImGuiNative.ImDrawList_AddTriangle(NativePtr, p1, p2, p3, col, thickness);
	}

	public unsafe void AddTriangleFilled(Vector2 p1, Vector2 p2, Vector2 p3, uint col)
	{
		ImGuiNative.ImDrawList_AddTriangleFilled(NativePtr, p1, p2, p3, col);
	}

	public unsafe void ChannelsMerge()
	{
		ImGuiNative.ImDrawList_ChannelsMerge(NativePtr);
	}

	public unsafe void ChannelsSetCurrent(int n)
	{
		ImGuiNative.ImDrawList_ChannelsSetCurrent(NativePtr, n);
	}

	public unsafe void ChannelsSplit(int count)
	{
		ImGuiNative.ImDrawList_ChannelsSplit(NativePtr, count);
	}

	public unsafe ImDrawListPtr CloneOutput()
	{
		return new ImDrawListPtr(ImGuiNative.ImDrawList_CloneOutput(NativePtr));
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImDrawList_destroy(NativePtr);
	}

	public unsafe Vector2 GetClipRectMax()
	{
		Vector2 result = default(Vector2);
		ImGuiNative.ImDrawList_GetClipRectMax(&result, NativePtr);
		return result;
	}

	public unsafe Vector2 GetClipRectMin()
	{
		Vector2 result = default(Vector2);
		ImGuiNative.ImDrawList_GetClipRectMin(&result, NativePtr);
		return result;
	}

	public unsafe void PathArcTo(Vector2 center, float radius, float a_min, float a_max)
	{
		int num_segments = 0;
		ImGuiNative.ImDrawList_PathArcTo(NativePtr, center, radius, a_min, a_max, num_segments);
	}

	public unsafe void PathArcTo(Vector2 center, float radius, float a_min, float a_max, int num_segments)
	{
		ImGuiNative.ImDrawList_PathArcTo(NativePtr, center, radius, a_min, a_max, num_segments);
	}

	public unsafe void PathArcToFast(Vector2 center, float radius, int a_min_of_12, int a_max_of_12)
	{
		ImGuiNative.ImDrawList_PathArcToFast(NativePtr, center, radius, a_min_of_12, a_max_of_12);
	}

	public unsafe void PathBezierCubicCurveTo(Vector2 p2, Vector2 p3, Vector2 p4)
	{
		int num_segments = 0;
		ImGuiNative.ImDrawList_PathBezierCubicCurveTo(NativePtr, p2, p3, p4, num_segments);
	}

	public unsafe void PathBezierCubicCurveTo(Vector2 p2, Vector2 p3, Vector2 p4, int num_segments)
	{
		ImGuiNative.ImDrawList_PathBezierCubicCurveTo(NativePtr, p2, p3, p4, num_segments);
	}

	public unsafe void PathBezierQuadraticCurveTo(Vector2 p2, Vector2 p3)
	{
		int num_segments = 0;
		ImGuiNative.ImDrawList_PathBezierQuadraticCurveTo(NativePtr, p2, p3, num_segments);
	}

	public unsafe void PathBezierQuadraticCurveTo(Vector2 p2, Vector2 p3, int num_segments)
	{
		ImGuiNative.ImDrawList_PathBezierQuadraticCurveTo(NativePtr, p2, p3, num_segments);
	}

	public unsafe void PathClear()
	{
		ImGuiNative.ImDrawList_PathClear(NativePtr);
	}

	public unsafe void PathFillConvex(uint col)
	{
		ImGuiNative.ImDrawList_PathFillConvex(NativePtr, col);
	}

	public unsafe void PathLineTo(Vector2 pos)
	{
		ImGuiNative.ImDrawList_PathLineTo(NativePtr, pos);
	}

	public unsafe void PathLineToMergeDuplicate(Vector2 pos)
	{
		ImGuiNative.ImDrawList_PathLineToMergeDuplicate(NativePtr, pos);
	}

	public unsafe void PathRect(Vector2 rect_min, Vector2 rect_max)
	{
		float rounding = 0f;
		ImDrawFlags flags = ImDrawFlags.None;
		ImGuiNative.ImDrawList_PathRect(NativePtr, rect_min, rect_max, rounding, flags);
	}

	public unsafe void PathRect(Vector2 rect_min, Vector2 rect_max, float rounding)
	{
		ImDrawFlags flags = ImDrawFlags.None;
		ImGuiNative.ImDrawList_PathRect(NativePtr, rect_min, rect_max, rounding, flags);
	}

	public unsafe void PathRect(Vector2 rect_min, Vector2 rect_max, float rounding, ImDrawFlags flags)
	{
		ImGuiNative.ImDrawList_PathRect(NativePtr, rect_min, rect_max, rounding, flags);
	}

	public unsafe void PathStroke(uint col)
	{
		ImDrawFlags flags = ImDrawFlags.None;
		float thickness = 1f;
		ImGuiNative.ImDrawList_PathStroke(NativePtr, col, flags, thickness);
	}

	public unsafe void PathStroke(uint col, ImDrawFlags flags)
	{
		float thickness = 1f;
		ImGuiNative.ImDrawList_PathStroke(NativePtr, col, flags, thickness);
	}

	public unsafe void PathStroke(uint col, ImDrawFlags flags, float thickness)
	{
		ImGuiNative.ImDrawList_PathStroke(NativePtr, col, flags, thickness);
	}

	public unsafe void PopClipRect()
	{
		ImGuiNative.ImDrawList_PopClipRect(NativePtr);
	}

	public unsafe void PopTextureID()
	{
		ImGuiNative.ImDrawList_PopTextureID(NativePtr);
	}

	public unsafe void PrimQuadUV(Vector2 a, Vector2 b, Vector2 c, Vector2 d, Vector2 uv_a, Vector2 uv_b, Vector2 uv_c, Vector2 uv_d, uint col)
	{
		ImGuiNative.ImDrawList_PrimQuadUV(NativePtr, a, b, c, d, uv_a, uv_b, uv_c, uv_d, col);
	}

	public unsafe void PrimRect(Vector2 a, Vector2 b, uint col)
	{
		ImGuiNative.ImDrawList_PrimRect(NativePtr, a, b, col);
	}

	public unsafe void PrimRectUV(Vector2 a, Vector2 b, Vector2 uv_a, Vector2 uv_b, uint col)
	{
		ImGuiNative.ImDrawList_PrimRectUV(NativePtr, a, b, uv_a, uv_b, col);
	}

	public unsafe void PrimReserve(int idx_count, int vtx_count)
	{
		ImGuiNative.ImDrawList_PrimReserve(NativePtr, idx_count, vtx_count);
	}

	public unsafe void PrimUnreserve(int idx_count, int vtx_count)
	{
		ImGuiNative.ImDrawList_PrimUnreserve(NativePtr, idx_count, vtx_count);
	}

	public unsafe void PrimVtx(Vector2 pos, Vector2 uv, uint col)
	{
		ImGuiNative.ImDrawList_PrimVtx(NativePtr, pos, uv, col);
	}

	public unsafe void PrimWriteIdx(ushort idx)
	{
		ImGuiNative.ImDrawList_PrimWriteIdx(NativePtr, idx);
	}

	public unsafe void PrimWriteVtx(Vector2 pos, Vector2 uv, uint col)
	{
		ImGuiNative.ImDrawList_PrimWriteVtx(NativePtr, pos, uv, col);
	}

	public unsafe void PushClipRect(Vector2 clip_rect_min, Vector2 clip_rect_max)
	{
		byte intersect_with_current_clip_rect = 0;
		ImGuiNative.ImDrawList_PushClipRect(NativePtr, clip_rect_min, clip_rect_max, intersect_with_current_clip_rect);
	}

	public unsafe void PushClipRect(Vector2 clip_rect_min, Vector2 clip_rect_max, bool intersect_with_current_clip_rect)
	{
		byte intersect_with_current_clip_rect2 = (byte)(intersect_with_current_clip_rect ? 1 : 0);
		ImGuiNative.ImDrawList_PushClipRect(NativePtr, clip_rect_min, clip_rect_max, intersect_with_current_clip_rect2);
	}

	public unsafe void PushClipRectFullScreen()
	{
		ImGuiNative.ImDrawList_PushClipRectFullScreen(NativePtr);
	}

	public unsafe void PushTextureID(IntPtr texture_id)
	{
		ImGuiNative.ImDrawList_PushTextureID(NativePtr, texture_id);
	}

	public unsafe void AddText(Vector2 pos, uint col, string text_begin)
	{
		int byteCount = Encoding.UTF8.GetByteCount(text_begin);
		byte* ptr = stackalloc byte[(int)(uint)(byteCount + 1)];
		fixed (char* chars = text_begin)
		{
			int bytes = Encoding.UTF8.GetBytes(chars, text_begin.Length, ptr, byteCount);
			ptr[bytes] = 0;
		}
		byte* text_end = null;
		ImGuiNative.ImDrawList_AddText_Vec2(NativePtr, pos, col, ptr, text_end);
	}

	public unsafe void AddText(ImFontPtr font, float font_size, Vector2 pos, uint col, string text_begin)
	{
		ImFont* nativePtr = font.NativePtr;
		int byteCount = Encoding.UTF8.GetByteCount(text_begin);
		byte* ptr = stackalloc byte[(int)(uint)(byteCount + 1)];
		fixed (char* chars = text_begin)
		{
			int bytes = Encoding.UTF8.GetBytes(chars, text_begin.Length, ptr, byteCount);
			ptr[bytes] = 0;
		}
		byte* text_end = null;
		float wrap_width = 0f;
		Vector4* cpu_fine_clip_rect = null;
		ImGuiNative.ImDrawList_AddText_FontPtr(NativePtr, nativePtr, font_size, pos, col, ptr, text_end, wrap_width, cpu_fine_clip_rect);
	}
}
[Flags]
public enum ImDrawListFlags
{
	None = 0,
	AntiAliasedLines = 1,
	AntiAliasedLinesUseTex = 2,
	AntiAliasedFill = 4,
	AllowVtxOffset = 8
}
public struct ImDrawListSplitter
{
	public int _Current;

	public int _Count;

	public ImVector _Channels;
}
public struct ImDrawListSplitterPtr
{
	public unsafe ImDrawListSplitter* NativePtr { get; }

	public unsafe ref int _Current => ref Unsafe.AsRef<int>(&NativePtr->_Current);

	public unsafe ref int _Count => ref Unsafe.AsRef<int>(&NativePtr->_Count);

	public unsafe ImPtrVector<ImDrawChannelPtr> _Channels => new ImPtrVector<ImDrawChannelPtr>(NativePtr->_Channels, Unsafe.SizeOf<ImDrawChannel>());

	public unsafe ImDrawListSplitterPtr(ImDrawListSplitter* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImDrawListSplitterPtr(IntPtr nativePtr)
	{
		NativePtr = (ImDrawListSplitter*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImDrawListSplitterPtr(ImDrawListSplitter* nativePtr)
	{
		return new ImDrawListSplitterPtr(nativePtr);
	}

	public unsafe static implicit operator ImDrawListSplitter*(ImDrawListSplitterPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImDrawListSplitterPtr(IntPtr nativePtr)
	{
		return new ImDrawListSplitterPtr(nativePtr);
	}

	public unsafe void Clear()
	{
		ImGuiNative.ImDrawListSplitter_Clear(NativePtr);
	}

	public unsafe void ClearFreeMemory()
	{
		ImGuiNative.ImDrawListSplitter_ClearFreeMemory(NativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImDrawListSplitter_destroy(NativePtr);
	}

	public unsafe void Merge(ImDrawListPtr draw_list)
	{
		ImDrawList* nativePtr = draw_list.NativePtr;
		ImGuiNative.ImDrawListSplitter_Merge(NativePtr, nativePtr);
	}

	public unsafe void SetCurrentChannel(ImDrawListPtr draw_list, int channel_idx)
	{
		ImDrawList* nativePtr = draw_list.NativePtr;
		ImGuiNative.ImDrawListSplitter_SetCurrentChannel(NativePtr, nativePtr, channel_idx);
	}

	public unsafe void Split(ImDrawListPtr draw_list, int count)
	{
		ImDrawList* nativePtr = draw_list.NativePtr;
		ImGuiNative.ImDrawListSplitter_Split(NativePtr, nativePtr, count);
	}
}
public struct ImDrawVert
{
	public Vector2 pos;

	public Vector2 uv;

	public uint col;
}
public struct ImDrawVertPtr
{
	public unsafe ImDrawVert* NativePtr { get; }

	public unsafe ref Vector2 pos => ref Unsafe.AsRef<Vector2>(&NativePtr->pos);

	public unsafe ref Vector2 uv => ref Unsafe.AsRef<Vector2>(&NativePtr->uv);

	public unsafe ref uint col => ref Unsafe.AsRef<uint>(&NativePtr->col);

	public unsafe ImDrawVertPtr(ImDrawVert* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImDrawVertPtr(IntPtr nativePtr)
	{
		NativePtr = (ImDrawVert*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImDrawVertPtr(ImDrawVert* nativePtr)
	{
		return new ImDrawVertPtr(nativePtr);
	}

	public unsafe static implicit operator ImDrawVert*(ImDrawVertPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImDrawVertPtr(IntPtr nativePtr)
	{
		return new ImDrawVertPtr(nativePtr);
	}
}
public struct ImFont
{
	public ImVector IndexAdvanceX;

	public float FallbackAdvanceX;

	public float FontSize;

	public ImVector IndexLookup;

	public ImVector Glyphs;

	public unsafe ImFontGlyph* FallbackGlyph;

	public unsafe ImFontAtlas* ContainerAtlas;

	public unsafe ImFontConfig* ConfigData;

	public short ConfigDataCount;

	public ushort FallbackChar;

	public ushort EllipsisChar;

	public ushort DotChar;

	public byte DirtyLookupTables;

	public float Scale;

	public float Ascent;

	public float Descent;

	public int MetricsTotalSurface;

	public unsafe fixed byte Used4kPagesMap[2];
}
public struct ImFontPtr
{
	public unsafe ImFont* NativePtr { get; }

	public unsafe ImVector<float> IndexAdvanceX => new ImVector<float>(NativePtr->IndexAdvanceX);

	public unsafe ref float FallbackAdvanceX => ref Unsafe.AsRef<float>(&NativePtr->FallbackAdvanceX);

	public unsafe ref float FontSize => ref Unsafe.AsRef<float>(&NativePtr->FontSize);

	public unsafe ImVector<ushort> IndexLookup => new ImVector<ushort>(NativePtr->IndexLookup);

	public unsafe ImPtrVector<ImFontGlyphPtr> Glyphs => new ImPtrVector<ImFontGlyphPtr>(NativePtr->Glyphs, Unsafe.SizeOf<ImFontGlyph>());

	public unsafe ImFontGlyphPtr FallbackGlyph => new ImFontGlyphPtr(NativePtr->FallbackGlyph);

	public unsafe ImFontAtlasPtr ContainerAtlas => new ImFontAtlasPtr(NativePtr->ContainerAtlas);

	public unsafe ImFontConfigPtr ConfigData => new ImFontConfigPtr(NativePtr->ConfigData);

	public unsafe ref short ConfigDataCount => ref Unsafe.AsRef<short>(&NativePtr->ConfigDataCount);

	public unsafe ref ushort FallbackChar => ref Unsafe.AsRef<ushort>(&NativePtr->FallbackChar);

	public unsafe ref ushort EllipsisChar => ref Unsafe.AsRef<ushort>(&NativePtr->EllipsisChar);

	public unsafe ref ushort DotChar => ref Unsafe.AsRef<ushort>(&NativePtr->DotChar);

	public unsafe ref bool DirtyLookupTables => ref Unsafe.AsRef<bool>(&NativePtr->DirtyLookupTables);

	public unsafe ref float Scale => ref Unsafe.AsRef<float>(&NativePtr->Scale);

	public unsafe ref float Ascent => ref Unsafe.AsRef<float>(&NativePtr->Ascent);

	public unsafe ref float Descent => ref Unsafe.AsRef<float>(&NativePtr->Descent);

	public unsafe ref int MetricsTotalSurface => ref Unsafe.AsRef<int>(&NativePtr->MetricsTotalSurface);

	public unsafe RangeAccessor<byte> Used4kPagesMap => new RangeAccessor<byte>(NativePtr->Used4kPagesMap, 2);

	public unsafe ImFontPtr(ImFont* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImFontPtr(IntPtr nativePtr)
	{
		NativePtr = (ImFont*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImFontPtr(ImFont* nativePtr)
	{
		return new ImFontPtr(nativePtr);
	}

	public unsafe static implicit operator ImFont*(ImFontPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImFontPtr(IntPtr nativePtr)
	{
		return new ImFontPtr(nativePtr);
	}

	public unsafe void AddGlyph(ImFontConfigPtr src_cfg, ushort c, float x0, float y0, float x1, float y1, float u0, float v0, float u1, float v1, float advance_x)
	{
		ImFontConfig* nativePtr = src_cfg.NativePtr;
		ImGuiNative.ImFont_AddGlyph(NativePtr, nativePtr, c, x0, y0, x1, y1, u0, v0, u1, v1, advance_x);
	}

	public unsafe void AddRemapChar(ushort dst, ushort src)
	{
		byte overwrite_dst = 1;
		ImGuiNative.ImFont_AddRemapChar(NativePtr, dst, src, overwrite_dst);
	}

	public unsafe void AddRemapChar(ushort dst, ushort src, bool overwrite_dst)
	{
		byte overwrite_dst2 = (byte)(overwrite_dst ? 1 : 0);
		ImGuiNative.ImFont_AddRemapChar(NativePtr, dst, src, overwrite_dst2);
	}

	public unsafe void BuildLookupTable()
	{
		ImGuiNative.ImFont_BuildLookupTable(NativePtr);
	}

	public unsafe void ClearOutputData()
	{
		ImGuiNative.ImFont_ClearOutputData(NativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImFont_destroy(NativePtr);
	}

	public unsafe ImFontGlyphPtr FindGlyph(ushort c)
	{
		return new ImFontGlyphPtr(ImGuiNative.ImFont_FindGlyph(NativePtr, c));
	}

	public unsafe ImFontGlyphPtr FindGlyphNoFallback(ushort c)
	{
		return new ImFontGlyphPtr(ImGuiNative.ImFont_FindGlyphNoFallback(NativePtr, c));
	}

	public unsafe float GetCharAdvance(ushort c)
	{
		return ImGuiNative.ImFont_GetCharAdvance(NativePtr, c);
	}

	public unsafe string GetDebugName()
	{
		return Util.StringFromPtr(ImGuiNative.ImFont_GetDebugName(NativePtr));
	}

	public unsafe void GrowIndex(int new_size)
	{
		ImGuiNative.ImFont_GrowIndex(NativePtr, new_size);
	}

	public unsafe bool IsLoaded()
	{
		return ImGuiNative.ImFont_IsLoaded(NativePtr) != 0;
	}

	public unsafe void RenderChar(ImDrawListPtr draw_list, float size, Vector2 pos, uint col, ushort c)
	{
		ImDrawList* nativePtr = draw_list.NativePtr;
		ImGuiNative.ImFont_RenderChar(NativePtr, nativePtr, size, pos, col, c);
	}

	public unsafe void SetGlyphVisible(ushort c, bool visible)
	{
		byte visible2 = (byte)(visible ? 1 : 0);
		ImGuiNative.ImFont_SetGlyphVisible(NativePtr, c, visible2);
	}
}
public struct ImFontAtlas
{
	public ImFontAtlasFlags Flags;

	public IntPtr TexID;

	public int TexDesiredWidth;

	public int TexGlyphPadding;

	public byte Locked;

	public byte TexReady;

	public byte TexPixelsUseColors;

	public unsafe byte* TexPixelsAlpha8;

	public unsafe uint* TexPixelsRGBA32;

	public int TexWidth;

	public int TexHeight;

	public Vector2 TexUvScale;

	public Vector2 TexUvWhitePixel;

	public ImVector Fonts;

	public ImVector CustomRects;

	public ImVector ConfigData;

	public Vector4 TexUvLines_0;

	public Vector4 TexUvLines_1;

	public Vector4 TexUvLines_2;

	public Vector4 TexUvLines_3;

	public Vector4 TexUvLines_4;

	public Vector4 TexUvLines_5;

	public Vector4 TexUvLines_6;

	public Vector4 TexUvLines_7;

	public Vector4 TexUvLines_8;

	public Vector4 TexUvLines_9;

	public Vector4 TexUvLines_10;

	public Vector4 TexUvLines_11;

	public Vector4 TexUvLines_12;

	public Vector4 TexUvLines_13;

	public Vector4 TexUvLines_14;

	public Vector4 TexUvLines_15;

	public Vector4 TexUvLines_16;

	public Vector4 TexUvLines_17;

	public Vector4 TexUvLines_18;

	public Vector4 TexUvLines_19;

	public Vector4 TexUvLines_20;

	public Vector4 TexUvLines_21;

	public Vector4 TexUvLines_22;

	public Vector4 TexUvLines_23;

	public Vector4 TexUvLines_24;

	public Vector4 TexUvLines_25;

	public Vector4 TexUvLines_26;

	public Vector4 TexUvLines_27;

	public Vector4 TexUvLines_28;

	public Vector4 TexUvLines_29;

	public Vector4 TexUvLines_30;

	public Vector4 TexUvLines_31;

	public Vector4 TexUvLines_32;

	public Vector4 TexUvLines_33;

	public Vector4 TexUvLines_34;

	public Vector4 TexUvLines_35;

	public Vector4 TexUvLines_36;

	public Vector4 TexUvLines_37;

	public Vector4 TexUvLines_38;

	public Vector4 TexUvLines_39;

	public Vector4 TexUvLines_40;

	public Vector4 TexUvLines_41;

	public Vector4 TexUvLines_42;

	public Vector4 TexUvLines_43;

	public Vector4 TexUvLines_44;

	public Vector4 TexUvLines_45;

	public Vector4 TexUvLines_46;

	public Vector4 TexUvLines_47;

	public Vector4 TexUvLines_48;

	public Vector4 TexUvLines_49;

	public Vector4 TexUvLines_50;

	public Vector4 TexUvLines_51;

	public Vector4 TexUvLines_52;

	public Vector4 TexUvLines_53;

	public Vector4 TexUvLines_54;

	public Vector4 TexUvLines_55;

	public Vector4 TexUvLines_56;

	public Vector4 TexUvLines_57;

	public Vector4 TexUvLines_58;

	public Vector4 TexUvLines_59;

	public Vector4 TexUvLines_60;

	public Vector4 TexUvLines_61;

	public Vector4 TexUvLines_62;

	public Vector4 TexUvLines_63;

	public unsafe IntPtr* FontBuilderIO;

	public uint FontBuilderFlags;

	public int PackIdMouseCursors;

	public int PackIdLines;
}
public struct ImFontAtlasPtr
{
	public unsafe ImFontAtlas* NativePtr { get; }

	public unsafe ref ImFontAtlasFlags Flags => ref Unsafe.AsRef<ImFontAtlasFlags>(&NativePtr->Flags);

	public unsafe ref IntPtr TexID => ref Unsafe.AsRef<IntPtr>(&NativePtr->TexID);

	public unsafe ref int TexDesiredWidth => ref Unsafe.AsRef<int>(&NativePtr->TexDesiredWidth);

	public unsafe ref int TexGlyphPadding => ref Unsafe.AsRef<int>(&NativePtr->TexGlyphPadding);

	public unsafe ref bool Locked => ref Unsafe.AsRef<bool>(&NativePtr->Locked);

	public unsafe ref bool TexReady => ref Unsafe.AsRef<bool>(&NativePtr->TexReady);

	public unsafe ref bool TexPixelsUseColors => ref Unsafe.AsRef<bool>(&NativePtr->TexPixelsUseColors);

	public unsafe IntPtr TexPixelsAlpha8
	{
		get
		{
			return (IntPtr)NativePtr->TexPixelsAlpha8;
		}
		set
		{
			NativePtr->TexPixelsAlpha8 = (byte*)(void*)value;
		}
	}

	public unsafe IntPtr TexPixelsRGBA32
	{
		get
		{
			return (IntPtr)NativePtr->TexPixelsRGBA32;
		}
		set
		{
			NativePtr->TexPixelsRGBA32 = (uint*)(void*)value;
		}
	}

	public unsafe ref int TexWidth => ref Unsafe.AsRef<int>(&NativePtr->TexWidth);

	public unsafe ref int TexHeight => ref Unsafe.AsRef<int>(&NativePtr->TexHeight);

	public unsafe ref Vector2 TexUvScale => ref Unsafe.AsRef<Vector2>(&NativePtr->TexUvScale);

	public unsafe ref Vector2 TexUvWhitePixel => ref Unsafe.AsRef<Vector2>(&NativePtr->TexUvWhitePixel);

	public unsafe ImVector<ImFontPtr> Fonts => new ImVector<ImFontPtr>(NativePtr->Fonts);

	public unsafe ImPtrVector<ImFontAtlasCustomRectPtr> CustomRects => new ImPtrVector<ImFontAtlasCustomRectPtr>(NativePtr->CustomRects, Unsafe.SizeOf<ImFontAtlasCustomRect>());

	public unsafe ImPtrVector<ImFontConfigPtr> ConfigData => new ImPtrVector<ImFontConfigPtr>(NativePtr->ConfigData, Unsafe.SizeOf<ImFontConfig>());

	public unsafe RangeAccessor<Vector4> TexUvLines => new RangeAccessor<Vector4>(&NativePtr->TexUvLines_0, 64);

	public unsafe IntPtr FontBuilderIO
	{
		get
		{
			return (IntPtr)NativePtr->FontBuilderIO;
		}
		set
		{
			NativePtr->FontBuilderIO = (IntPtr*)(void*)value;
		}
	}

	public unsafe ref uint FontBuilderFlags => ref Unsafe.AsRef<uint>(&NativePtr->FontBuilderFlags);

	public unsafe ref int PackIdMouseCursors => ref Unsafe.AsRef<int>(&NativePtr->PackIdMouseCursors);

	public unsafe ref int PackIdLines => ref Unsafe.AsRef<int>(&NativePtr->PackIdLines);

	public unsafe ImFontAtlasPtr(ImFontAtlas* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImFontAtlasPtr(IntPtr nativePtr)
	{
		NativePtr = (ImFontAtlas*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImFontAtlasPtr(ImFontAtlas* nativePtr)
	{
		return new ImFontAtlasPtr(nativePtr);
	}

	public unsafe static implicit operator ImFontAtlas*(ImFontAtlasPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImFontAtlasPtr(IntPtr nativePtr)
	{
		return new ImFontAtlasPtr(nativePtr);
	}

	public unsafe int AddCustomRectFontGlyph(ImFontPtr font, ushort id, int width, int height, float advance_x)
	{
		ImFont* nativePtr = font.NativePtr;
		return ImGuiNative.ImFontAtlas_AddCustomRectFontGlyph(NativePtr, nativePtr, id, width, height, advance_x, default(Vector2));
	}

	public unsafe int AddCustomRectFontGlyph(ImFontPtr font, ushort id, int width, int height, float advance_x, Vector2 offset)
	{
		ImFont* nativePtr = font.NativePtr;
		return ImGuiNative.ImFontAtlas_AddCustomRectFontGlyph(NativePtr, nativePtr, id, width, height, advance_x, offset);
	}

	public unsafe int AddCustomRectRegular(int width, int height)
	{
		return ImGuiNative.ImFontAtlas_AddCustomRectRegular(NativePtr, width, height);
	}

	public unsafe ImFontPtr AddFont(ImFontConfigPtr font_cfg)
	{
		ImFontConfig* nativePtr = font_cfg.NativePtr;
		return new ImFontPtr(ImGuiNative.ImFontAtlas_AddFont(NativePtr, nativePtr));
	}

	public unsafe ImFontPtr AddFontDefault()
	{
		ImFontConfig* font_cfg = null;
		return new ImFontPtr(ImGuiNative.ImFontAtlas_AddFontDefault(NativePtr, font_cfg));
	}

	public unsafe ImFontPtr AddFontDefault(ImFontConfigPtr font_cfg)
	{
		ImFontConfig* nativePtr = font_cfg.NativePtr;
		return new ImFontPtr(ImGuiNative.ImFontAtlas_AddFontDefault(NativePtr, nativePtr));
	}

	public unsafe ImFontPtr AddFontFromFileTTF(string filename, float size_pixels)
	{
		int num = 0;
		byte* ptr;
		if (filename != null)
		{
			num = Encoding.UTF8.GetByteCount(filename);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(filename, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImFontConfig* font_cfg = null;
		ushort* glyph_ranges = null;
		ImFont* nativePtr = ImGuiNative.ImFontAtlas_AddFontFromFileTTF(NativePtr, ptr, size_pixels, font_cfg, glyph_ranges);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return new ImFontPtr(nativePtr);
	}

	public unsafe ImFontPtr AddFontFromFileTTF(string filename, float size_pixels, ImFontConfigPtr font_cfg)
	{
		int num = 0;
		byte* ptr;
		if (filename != null)
		{
			num = Encoding.UTF8.GetByteCount(filename);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(filename, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImFontConfig* nativePtr = font_cfg.NativePtr;
		ushort* glyph_ranges = null;
		ImFont* nativePtr2 = ImGuiNative.ImFontAtlas_AddFontFromFileTTF(NativePtr, ptr, size_pixels, nativePtr, glyph_ranges);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return new ImFontPtr(nativePtr2);
	}

	public unsafe ImFontPtr AddFontFromFileTTF(string filename, float size_pixels, ImFontConfigPtr font_cfg, IntPtr glyph_ranges)
	{
		int num = 0;
		byte* ptr;
		if (filename != null)
		{
			num = Encoding.UTF8.GetByteCount(filename);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(filename, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImFontConfig* nativePtr = font_cfg.NativePtr;
		ushort* glyph_ranges2 = (ushort*)glyph_ranges.ToPointer();
		ImFont* nativePtr2 = ImGuiNative.ImFontAtlas_AddFontFromFileTTF(NativePtr, ptr, size_pixels, nativePtr, glyph_ranges2);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return new ImFontPtr(nativePtr2);
	}

	public unsafe ImFontPtr AddFontFromMemoryCompressedBase85TTF(string compressed_font_data_base85, float size_pixels)
	{
		int num = 0;
		byte* ptr;
		if (compressed_font_data_base85 != null)
		{
			num = Encoding.UTF8.GetByteCount(compressed_font_data_base85);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(compressed_font_data_base85, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImFontConfig* font_cfg = null;
		ushort* glyph_ranges = null;
		ImFont* nativePtr = ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(NativePtr, ptr, size_pixels, font_cfg, glyph_ranges);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return new ImFontPtr(nativePtr);
	}

	public unsafe ImFontPtr AddFontFromMemoryCompressedBase85TTF(string compressed_font_data_base85, float size_pixels, ImFontConfigPtr font_cfg)
	{
		int num = 0;
		byte* ptr;
		if (compressed_font_data_base85 != null)
		{
			num = Encoding.UTF8.GetByteCount(compressed_font_data_base85);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(compressed_font_data_base85, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImFontConfig* nativePtr = font_cfg.NativePtr;
		ushort* glyph_ranges = null;
		ImFont* nativePtr2 = ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(NativePtr, ptr, size_pixels, nativePtr, glyph_ranges);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return new ImFontPtr(nativePtr2);
	}

	public unsafe ImFontPtr AddFontFromMemoryCompressedBase85TTF(string compressed_font_data_base85, float size_pixels, ImFontConfigPtr font_cfg, IntPtr glyph_ranges)
	{
		int num = 0;
		byte* ptr;
		if (compressed_font_data_base85 != null)
		{
			num = Encoding.UTF8.GetByteCount(compressed_font_data_base85);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(compressed_font_data_base85, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImFontConfig* nativePtr = font_cfg.NativePtr;
		ushort* glyph_ranges2 = (ushort*)glyph_ranges.ToPointer();
		ImFont* nativePtr2 = ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(NativePtr, ptr, size_pixels, nativePtr, glyph_ranges2);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return new ImFontPtr(nativePtr2);
	}

	public unsafe ImFontPtr AddFontFromMemoryCompressedTTF(IntPtr compressed_font_data, int compressed_font_size, float size_pixels)
	{
		void* compressed_font_data2 = compressed_font_data.ToPointer();
		ImFontConfig* font_cfg = null;
		ushort* glyph_ranges = null;
		return new ImFontPtr(ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedTTF(NativePtr, compressed_font_data2, compressed_font_size, size_pixels, font_cfg, glyph_ranges));
	}

	public unsafe ImFontPtr AddFontFromMemoryCompressedTTF(IntPtr compressed_font_data, int compressed_font_size, float size_pixels, ImFontConfigPtr font_cfg)
	{
		void* compressed_font_data2 = compressed_font_data.ToPointer();
		ImFontConfig* nativePtr = font_cfg.NativePtr;
		ushort* glyph_ranges = null;
		return new ImFontPtr(ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedTTF(NativePtr, compressed_font_data2, compressed_font_size, size_pixels, nativePtr, glyph_ranges));
	}

	public unsafe ImFontPtr AddFontFromMemoryCompressedTTF(IntPtr compressed_font_data, int compressed_font_size, float size_pixels, ImFontConfigPtr font_cfg, IntPtr glyph_ranges)
	{
		void* compressed_font_data2 = compressed_font_data.ToPointer();
		ImFontConfig* nativePtr = font_cfg.NativePtr;
		ushort* glyph_ranges2 = (ushort*)glyph_ranges.ToPointer();
		return new ImFontPtr(ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedTTF(NativePtr, compressed_font_data2, compressed_font_size, size_pixels, nativePtr, glyph_ranges2));
	}

	public unsafe ImFontPtr AddFontFromMemoryTTF(IntPtr font_data, int font_size, float size_pixels)
	{
		void* font_data2 = font_data.ToPointer();
		ImFontConfig* font_cfg = null;
		ushort* glyph_ranges = null;
		return new ImFontPtr(ImGuiNative.ImFontAtlas_AddFontFromMemoryTTF(NativePtr, font_data2, font_size, size_pixels, font_cfg, glyph_ranges));
	}

	public unsafe ImFontPtr AddFontFromMemoryTTF(IntPtr font_data, int font_size, float size_pixels, ImFontConfigPtr font_cfg)
	{
		void* font_data2 = font_data.ToPointer();
		ImFontConfig* nativePtr = font_cfg.NativePtr;
		ushort* glyph_ranges = null;
		return new ImFontPtr(ImGuiNative.ImFontAtlas_AddFontFromMemoryTTF(NativePtr, font_data2, font_size, size_pixels, nativePtr, glyph_ranges));
	}

	public unsafe ImFontPtr AddFontFromMemoryTTF(IntPtr font_data, int font_size, float size_pixels, ImFontConfigPtr font_cfg, IntPtr glyph_ranges)
	{
		void* font_data2 = font_data.ToPointer();
		ImFontConfig* nativePtr = font_cfg.NativePtr;
		ushort* glyph_ranges2 = (ushort*)glyph_ranges.ToPointer();
		return new ImFontPtr(ImGuiNative.ImFontAtlas_AddFontFromMemoryTTF(NativePtr, font_data2, font_size, size_pixels, nativePtr, glyph_ranges2));
	}

	public unsafe bool Build()
	{
		return ImGuiNative.ImFontAtlas_Build(NativePtr) != 0;
	}

	public unsafe void CalcCustomRectUV(ImFontAtlasCustomRectPtr rect, out Vector2 out_uv_min, out Vector2 out_uv_max)
	{
		ImFontAtlasCustomRect* nativePtr = rect.NativePtr;
		fixed (Vector2* out_uv_min2 = &out_uv_min)
		{
			fixed (Vector2* out_uv_max2 = &out_uv_max)
			{
				ImGuiNative.ImFontAtlas_CalcCustomRectUV(NativePtr, nativePtr, out_uv_min2, out_uv_max2);
			}
		}
	}

	public unsafe void Clear()
	{
		ImGuiNative.ImFontAtlas_Clear(NativePtr);
	}

	public unsafe void ClearFonts()
	{
		ImGuiNative.ImFontAtlas_ClearFonts(NativePtr);
	}

	public unsafe void ClearInputData()
	{
		ImGuiNative.ImFontAtlas_ClearInputData(NativePtr);
	}

	public unsafe void ClearTexData()
	{
		ImGuiNative.ImFontAtlas_ClearTexData(NativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImFontAtlas_destroy(NativePtr);
	}

	public unsafe ImFontAtlasCustomRectPtr GetCustomRectByIndex(int index)
	{
		return new ImFontAtlasCustomRectPtr(ImGuiNative.ImFontAtlas_GetCustomRectByIndex(NativePtr, index));
	}

	public unsafe IntPtr GetGlyphRangesChineseFull()
	{
		return (IntPtr)ImGuiNative.ImFontAtlas_GetGlyphRangesChineseFull(NativePtr);
	}

	public unsafe IntPtr GetGlyphRangesChineseSimplifiedCommon()
	{
		return (IntPtr)ImGuiNative.ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon(NativePtr);
	}

	public unsafe IntPtr GetGlyphRangesCyrillic()
	{
		return (IntPtr)ImGuiNative.ImFontAtlas_GetGlyphRangesCyrillic(NativePtr);
	}

	public unsafe IntPtr GetGlyphRangesDefault()
	{
		return (IntPtr)ImGuiNative.ImFontAtlas_GetGlyphRangesDefault(NativePtr);
	}

	public unsafe IntPtr GetGlyphRangesGreek()
	{
		return (IntPtr)ImGuiNative.ImFontAtlas_GetGlyphRangesGreek(NativePtr);
	}

	public unsafe IntPtr GetGlyphRangesJapanese()
	{
		return (IntPtr)ImGuiNative.ImFontAtlas_GetGlyphRangesJapanese(NativePtr);
	}

	public unsafe IntPtr GetGlyphRangesKorean()
	{
		return (IntPtr)ImGuiNative.ImFontAtlas_GetGlyphRangesKorean(NativePtr);
	}

	public unsafe IntPtr GetGlyphRangesThai()
	{
		return (IntPtr)ImGuiNative.ImFontAtlas_GetGlyphRangesThai(NativePtr);
	}

	public unsafe IntPtr GetGlyphRangesVietnamese()
	{
		return (IntPtr)ImGuiNative.ImFontAtlas_GetGlyphRangesVietnamese(NativePtr);
	}

	public unsafe bool GetMouseCursorTexData(ImGuiMouseCursor cursor, out Vector2 out_offset, out Vector2 out_size, out Vector2 out_uv_border, out Vector2 out_uv_fill)
	{
		fixed (Vector2* out_offset2 = &out_offset)
		{
			fixed (Vector2* out_size2 = &out_size)
			{
				fixed (Vector2* out_uv_border2 = &out_uv_border)
				{
					fixed (Vector2* out_uv_fill2 = &out_uv_fill)
					{
						return ImGuiNative.ImFontAtlas_GetMouseCursorTexData(NativePtr, cursor, out_offset2, out_size2, out_uv_border2, out_uv_fill2) != 0;
					}
				}
			}
		}
	}

	public unsafe void GetTexDataAsAlpha8(out byte* out_pixels, out int out_width, out int out_height)
	{
		int* out_bytes_per_pixel = null;
		fixed (byte** out_pixels2 = &out_pixels)
		{
			fixed (int* out_width2 = &out_width)
			{
				fixed (int* out_height2 = &out_height)
				{
					ImGuiNative.ImFontAtlas_GetTexDataAsAlpha8(NativePtr, out_pixels2, out_width2, out_height2, out_bytes_per_pixel);
				}
			}
		}
	}

	public unsafe void GetTexDataAsAlpha8(out byte* out_pixels, out int out_width, out int out_height, out int out_bytes_per_pixel)
	{
		fixed (byte** out_pixels2 = &out_pixels)
		{
			fixed (int* out_width2 = &out_width)
			{
				fixed (int* out_height2 = &out_height)
				{
					fixed (int* out_bytes_per_pixel2 = &out_bytes_per_pixel)
					{
						ImGuiNative.ImFontAtlas_GetTexDataAsAlpha8(NativePtr, out_pixels2, out_width2, out_height2, out_bytes_per_pixel2);
					}
				}
			}
		}
	}

	public unsafe void GetTexDataAsAlpha8(out IntPtr out_pixels, out int out_width, out int out_height)
	{
		int* out_bytes_per_pixel = null;
		fixed (IntPtr* out_pixels2 = &out_pixels)
		{
			fixed (int* out_width2 = &out_width)
			{
				fixed (int* out_height2 = &out_height)
				{
					ImGuiNative.ImFontAtlas_GetTexDataAsAlpha8(NativePtr, out_pixels2, out_width2, out_height2, out_bytes_per_pixel);
				}
			}
		}
	}

	public unsafe void GetTexDataAsAlpha8(out IntPtr out_pixels, out int out_width, out int out_height, out int out_bytes_per_pixel)
	{
		fixed (IntPtr* out_pixels2 = &out_pixels)
		{
			fixed (int* out_width2 = &out_width)
			{
				fixed (int* out_height2 = &out_height)
				{
					fixed (int* out_bytes_per_pixel2 = &out_bytes_per_pixel)
					{
						ImGuiNative.ImFontAtlas_GetTexDataAsAlpha8(NativePtr, out_pixels2, out_width2, out_height2, out_bytes_per_pixel2);
					}
				}
			}
		}
	}

	public unsafe void GetTexDataAsRGBA32(out byte* out_pixels, out int out_width, out int out_height)
	{
		int* out_bytes_per_pixel = null;
		fixed (byte** out_pixels2 = &out_pixels)
		{
			fixed (int* out_width2 = &out_width)
			{
				fixed (int* out_height2 = &out_height)
				{
					ImGuiNative.ImFontAtlas_GetTexDataAsRGBA32(NativePtr, out_pixels2, out_width2, out_height2, out_bytes_per_pixel);
				}
			}
		}
	}

	public unsafe void GetTexDataAsRGBA32(out byte* out_pixels, out int out_width, out int out_height, out int out_bytes_per_pixel)
	{
		fixed (byte** out_pixels2 = &out_pixels)
		{
			fixed (int* out_width2 = &out_width)
			{
				fixed (int* out_height2 = &out_height)
				{
					fixed (int* out_bytes_per_pixel2 = &out_bytes_per_pixel)
					{
						ImGuiNative.ImFontAtlas_GetTexDataAsRGBA32(NativePtr, out_pixels2, out_width2, out_height2, out_bytes_per_pixel2);
					}
				}
			}
		}
	}

	public unsafe void GetTexDataAsRGBA32(out IntPtr out_pixels, out int out_width, out int out_height)
	{
		int* out_bytes_per_pixel = null;
		fixed (IntPtr* out_pixels2 = &out_pixels)
		{
			fixed (int* out_width2 = &out_width)
			{
				fixed (int* out_height2 = &out_height)
				{
					ImGuiNative.ImFontAtlas_GetTexDataAsRGBA32(NativePtr, out_pixels2, out_width2, out_height2, out_bytes_per_pixel);
				}
			}
		}
	}

	public unsafe void GetTexDataAsRGBA32(out IntPtr out_pixels, out int out_width, out int out_height, out int out_bytes_per_pixel)
	{
		fixed (IntPtr* out_pixels2 = &out_pixels)
		{
			fixed (int* out_width2 = &out_width)
			{
				fixed (int* out_height2 = &out_height)
				{
					fixed (int* out_bytes_per_pixel2 = &out_bytes_per_pixel)
					{
						ImGuiNative.ImFontAtlas_GetTexDataAsRGBA32(NativePtr, out_pixels2, out_width2, out_height2, out_bytes_per_pixel2);
					}
				}
			}
		}
	}

	public unsafe bool IsBuilt()
	{
		return ImGuiNative.ImFontAtlas_IsBuilt(NativePtr) != 0;
	}

	public unsafe void SetTexID(IntPtr id)
	{
		ImGuiNative.ImFontAtlas_SetTexID(NativePtr, id);
	}
}
public struct ImFontAtlasCustomRect
{
	public ushort Width;

	public ushort Height;

	public ushort X;

	public ushort Y;

	public uint GlyphID;

	public float GlyphAdvanceX;

	public Vector2 GlyphOffset;

	public unsafe ImFont* Font;
}
public struct ImFontAtlasCustomRectPtr
{
	public unsafe ImFontAtlasCustomRect* NativePtr { get; }

	public unsafe ref ushort Width => ref Unsafe.AsRef<ushort>(&NativePtr->Width);

	public unsafe ref ushort Height => ref Unsafe.AsRef<ushort>(&NativePtr->Height);

	public unsafe ref ushort X => ref Unsafe.AsRef<ushort>(&NativePtr->X);

	public unsafe ref ushort Y => ref Unsafe.AsRef<ushort>(&NativePtr->Y);

	public unsafe ref uint GlyphID => ref Unsafe.AsRef<uint>(&NativePtr->GlyphID);

	public unsafe ref float GlyphAdvanceX => ref Unsafe.AsRef<float>(&NativePtr->GlyphAdvanceX);

	public unsafe ref Vector2 GlyphOffset => ref Unsafe.AsRef<Vector2>(&NativePtr->GlyphOffset);

	public unsafe ImFontPtr Font => new ImFontPtr(NativePtr->Font);

	public unsafe ImFontAtlasCustomRectPtr(ImFontAtlasCustomRect* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImFontAtlasCustomRectPtr(IntPtr nativePtr)
	{
		NativePtr = (ImFontAtlasCustomRect*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImFontAtlasCustomRectPtr(ImFontAtlasCustomRect* nativePtr)
	{
		return new ImFontAtlasCustomRectPtr(nativePtr);
	}

	public unsafe static implicit operator ImFontAtlasCustomRect*(ImFontAtlasCustomRectPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImFontAtlasCustomRectPtr(IntPtr nativePtr)
	{
		return new ImFontAtlasCustomRectPtr(nativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImFontAtlasCustomRect_destroy(NativePtr);
	}

	public unsafe bool IsPacked()
	{
		return ImGuiNative.ImFontAtlasCustomRect_IsPacked(NativePtr) != 0;
	}
}
[Flags]
public enum ImFontAtlasFlags
{
	None = 0,
	NoPowerOfTwoHeight = 1,
	NoMouseCursors = 2,
	NoBakedLines = 4
}
public struct ImFontConfig
{
	public unsafe void* FontData;

	public int FontDataSize;

	public byte FontDataOwnedByAtlas;

	public int FontNo;

	public float SizePixels;

	public int OversampleH;

	public int OversampleV;

	public byte PixelSnapH;

	public Vector2 GlyphExtraSpacing;

	public Vector2 GlyphOffset;

	public unsafe ushort* GlyphRanges;

	public float GlyphMinAdvanceX;

	public float GlyphMaxAdvanceX;

	public byte MergeMode;

	public uint FontBuilderFlags;

	public float RasterizerMultiply;

	public ushort EllipsisChar;

	public unsafe fixed byte Name[40];

	public unsafe ImFont* DstFont;
}
public struct ImFontConfigPtr
{
	public unsafe ImFontConfig* NativePtr { get; }

	public unsafe IntPtr FontData
	{
		get
		{
			return (IntPtr)NativePtr->FontData;
		}
		set
		{
			NativePtr->FontData = (void*)value;
		}
	}

	public unsafe ref int FontDataSize => ref Unsafe.AsRef<int>(&NativePtr->FontDataSize);

	public unsafe ref bool FontDataOwnedByAtlas => ref Unsafe.AsRef<bool>(&NativePtr->FontDataOwnedByAtlas);

	public unsafe ref int FontNo => ref Unsafe.AsRef<int>(&NativePtr->FontNo);

	public unsafe ref float SizePixels => ref Unsafe.AsRef<float>(&NativePtr->SizePixels);

	public unsafe ref int OversampleH => ref Unsafe.AsRef<int>(&NativePtr->OversampleH);

	public unsafe ref int OversampleV => ref Unsafe.AsRef<int>(&NativePtr->OversampleV);

	public unsafe ref bool PixelSnapH => ref Unsafe.AsRef<bool>(&NativePtr->PixelSnapH);

	public unsafe ref Vector2 GlyphExtraSpacing => ref Unsafe.AsRef<Vector2>(&NativePtr->GlyphExtraSpacing);

	public unsafe ref Vector2 GlyphOffset => ref Unsafe.AsRef<Vector2>(&NativePtr->GlyphOffset);

	public unsafe IntPtr GlyphRanges
	{
		get
		{
			return (IntPtr)NativePtr->GlyphRanges;
		}
		set
		{
			NativePtr->GlyphRanges = (ushort*)(void*)value;
		}
	}

	public unsafe ref float GlyphMinAdvanceX => ref Unsafe.AsRef<float>(&NativePtr->GlyphMinAdvanceX);

	public unsafe ref float GlyphMaxAdvanceX => ref Unsafe.AsRef<float>(&NativePtr->GlyphMaxAdvanceX);

	public unsafe ref bool MergeMode => ref Unsafe.AsRef<bool>(&NativePtr->MergeMode);

	public unsafe ref uint FontBuilderFlags => ref Unsafe.AsRef<uint>(&NativePtr->FontBuilderFlags);

	public unsafe ref float RasterizerMultiply => ref Unsafe.AsRef<float>(&NativePtr->RasterizerMultiply);

	public unsafe ref ushort EllipsisChar => ref Unsafe.AsRef<ushort>(&NativePtr->EllipsisChar);

	public unsafe RangeAccessor<byte> Name => new RangeAccessor<byte>(NativePtr->Name, 40);

	public unsafe ImFontPtr DstFont => new ImFontPtr(NativePtr->DstFont);

	public unsafe ImFontConfigPtr(ImFontConfig* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImFontConfigPtr(IntPtr nativePtr)
	{
		NativePtr = (ImFontConfig*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImFontConfigPtr(ImFontConfig* nativePtr)
	{
		return new ImFontConfigPtr(nativePtr);
	}

	public unsafe static implicit operator ImFontConfig*(ImFontConfigPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImFontConfigPtr(IntPtr nativePtr)
	{
		return new ImFontConfigPtr(nativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImFontConfig_destroy(NativePtr);
	}
}
public struct ImFontGlyph
{
	public uint Colored;

	public uint Visible;

	public uint Codepoint;

	public float AdvanceX;

	public float X0;

	public float Y0;

	public float X1;

	public float Y1;

	public float U0;

	public float V0;

	public float U1;

	public float V1;
}
public struct ImFontGlyphPtr
{
	public unsafe ImFontGlyph* NativePtr { get; }

	public unsafe ref uint Colored => ref Unsafe.AsRef<uint>(&NativePtr->Colored);

	public unsafe ref uint Visible => ref Unsafe.AsRef<uint>(&NativePtr->Visible);

	public unsafe ref uint Codepoint => ref Unsafe.AsRef<uint>(&NativePtr->Codepoint);

	public unsafe ref float AdvanceX => ref Unsafe.AsRef<float>(&NativePtr->AdvanceX);

	public unsafe ref float X0 => ref Unsafe.AsRef<float>(&NativePtr->X0);

	public unsafe ref float Y0 => ref Unsafe.AsRef<float>(&NativePtr->Y0);

	public unsafe ref float X1 => ref Unsafe.AsRef<float>(&NativePtr->X1);

	public unsafe ref float Y1 => ref Unsafe.AsRef<float>(&NativePtr->Y1);

	public unsafe ref float U0 => ref Unsafe.AsRef<float>(&NativePtr->U0);

	public unsafe ref float V0 => ref Unsafe.AsRef<float>(&NativePtr->V0);

	public unsafe ref float U1 => ref Unsafe.AsRef<float>(&NativePtr->U1);

	public unsafe ref float V1 => ref Unsafe.AsRef<float>(&NativePtr->V1);

	public unsafe ImFontGlyphPtr(ImFontGlyph* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImFontGlyphPtr(IntPtr nativePtr)
	{
		NativePtr = (ImFontGlyph*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImFontGlyphPtr(ImFontGlyph* nativePtr)
	{
		return new ImFontGlyphPtr(nativePtr);
	}

	public unsafe static implicit operator ImFontGlyph*(ImFontGlyphPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImFontGlyphPtr(IntPtr nativePtr)
	{
		return new ImFontGlyphPtr(nativePtr);
	}
}
public struct ImFontGlyphRangesBuilder
{
	public ImVector UsedChars;
}
public struct ImFontGlyphRangesBuilderPtr
{
	public unsafe ImFontGlyphRangesBuilder* NativePtr { get; }

	public unsafe ImVector<uint> UsedChars => new ImVector<uint>(NativePtr->UsedChars);

	public unsafe ImFontGlyphRangesBuilderPtr(ImFontGlyphRangesBuilder* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImFontGlyphRangesBuilderPtr(IntPtr nativePtr)
	{
		NativePtr = (ImFontGlyphRangesBuilder*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImFontGlyphRangesBuilderPtr(ImFontGlyphRangesBuilder* nativePtr)
	{
		return new ImFontGlyphRangesBuilderPtr(nativePtr);
	}

	public unsafe static implicit operator ImFontGlyphRangesBuilder*(ImFontGlyphRangesBuilderPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImFontGlyphRangesBuilderPtr(IntPtr nativePtr)
	{
		return new ImFontGlyphRangesBuilderPtr(nativePtr);
	}

	public unsafe void AddChar(ushort c)
	{
		ImGuiNative.ImFontGlyphRangesBuilder_AddChar(NativePtr, c);
	}

	public unsafe void AddRanges(IntPtr ranges)
	{
		ushort* ranges2 = (ushort*)ranges.ToPointer();
		ImGuiNative.ImFontGlyphRangesBuilder_AddRanges(NativePtr, ranges2);
	}

	public unsafe void AddText(string text)
	{
		int num = 0;
		byte* ptr;
		if (text != null)
		{
			num = Encoding.UTF8.GetByteCount(text);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(text, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte* text_end = null;
		ImGuiNative.ImFontGlyphRangesBuilder_AddText(NativePtr, ptr, text_end);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe void BuildRanges(out ImVector out_ranges)
	{
		fixed (ImVector* out_ranges2 = &out_ranges)
		{
			ImGuiNative.ImFontGlyphRangesBuilder_BuildRanges(NativePtr, out_ranges2);
		}
	}

	public unsafe void Clear()
	{
		ImGuiNative.ImFontGlyphRangesBuilder_Clear(NativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImFontGlyphRangesBuilder_destroy(NativePtr);
	}

	public unsafe bool GetBit(uint n)
	{
		return ImGuiNative.ImFontGlyphRangesBuilder_GetBit(NativePtr, n) != 0;
	}

	public unsafe void SetBit(uint n)
	{
		ImGuiNative.ImFontGlyphRangesBuilder_SetBit(NativePtr, n);
	}
}
public static class ImGui
{
	public unsafe static ImGuiPayloadPtr AcceptDragDropPayload(string type)
	{
		int num = 0;
		byte* ptr;
		if (type != null)
		{
			num = Encoding.UTF8.GetByteCount(type);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(type, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiDragDropFlags flags = ImGuiDragDropFlags.None;
		ImGuiPayload* nativePtr = ImGuiNative.igAcceptDragDropPayload(ptr, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return new ImGuiPayloadPtr(nativePtr);
	}

	public unsafe static ImGuiPayloadPtr AcceptDragDropPayload(string type, ImGuiDragDropFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (type != null)
		{
			num = Encoding.UTF8.GetByteCount(type);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(type, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiPayload* nativePtr = ImGuiNative.igAcceptDragDropPayload(ptr, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return new ImGuiPayloadPtr(nativePtr);
	}

	public static void AlignTextToFramePadding()
	{
		ImGuiNative.igAlignTextToFramePadding();
	}

	public unsafe static bool ArrowButton(string str_id, ImGuiDir dir)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igArrowButton(ptr, dir);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool Begin(string name)
	{
		int num = 0;
		byte* ptr;
		if (name != null)
		{
			num = Encoding.UTF8.GetByteCount(name);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(name, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte* p_open = null;
		ImGuiWindowFlags flags = ImGuiWindowFlags.None;
		byte num2 = ImGuiNative.igBegin(ptr, p_open, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool Begin(string name, ref bool p_open)
	{
		int num = 0;
		byte* ptr;
		if (name != null)
		{
			num = Encoding.UTF8.GetByteCount(name);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(name, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte b = (byte)(p_open ? 1 : 0);
		byte* p_open2 = &b;
		ImGuiWindowFlags flags = ImGuiWindowFlags.None;
		byte num2 = ImGuiNative.igBegin(ptr, p_open2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		p_open = b != 0;
		return num2 != 0;
	}

	public unsafe static bool Begin(string name, ref bool p_open, ImGuiWindowFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (name != null)
		{
			num = Encoding.UTF8.GetByteCount(name);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(name, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte b = (byte)(p_open ? 1 : 0);
		byte* p_open2 = &b;
		byte num2 = ImGuiNative.igBegin(ptr, p_open2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		p_open = b != 0;
		return num2 != 0;
	}

	public unsafe static bool BeginChild(string str_id)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		Vector2 size = default(Vector2);
		byte border = 0;
		ImGuiWindowFlags flags = ImGuiWindowFlags.None;
		byte num2 = ImGuiNative.igBeginChild_Str(ptr, size, border, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginChild(string str_id, Vector2 size)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte border = 0;
		ImGuiWindowFlags flags = ImGuiWindowFlags.None;
		byte num2 = ImGuiNative.igBeginChild_Str(ptr, size, border, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginChild(string str_id, Vector2 size, bool border)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte border2 = (byte)(border ? 1 : 0);
		ImGuiWindowFlags flags = ImGuiWindowFlags.None;
		byte num2 = ImGuiNative.igBeginChild_Str(ptr, size, border2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginChild(string str_id, Vector2 size, bool border, ImGuiWindowFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte border2 = (byte)(border ? 1 : 0);
		byte num2 = ImGuiNative.igBeginChild_Str(ptr, size, border2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public static bool BeginChild(uint id)
	{
		Vector2 size = default(Vector2);
		byte border = 0;
		ImGuiWindowFlags flags = ImGuiWindowFlags.None;
		return ImGuiNative.igBeginChild_ID(id, size, border, flags) != 0;
	}

	public static bool BeginChild(uint id, Vector2 size)
	{
		byte border = 0;
		ImGuiWindowFlags flags = ImGuiWindowFlags.None;
		return ImGuiNative.igBeginChild_ID(id, size, border, flags) != 0;
	}

	public static bool BeginChild(uint id, Vector2 size, bool border)
	{
		byte border2 = (byte)(border ? 1 : 0);
		ImGuiWindowFlags flags = ImGuiWindowFlags.None;
		return ImGuiNative.igBeginChild_ID(id, size, border2, flags) != 0;
	}

	public static bool BeginChild(uint id, Vector2 size, bool border, ImGuiWindowFlags flags)
	{
		byte border2 = (byte)(border ? 1 : 0);
		return ImGuiNative.igBeginChild_ID(id, size, border2, flags) != 0;
	}

	public static bool BeginChildFrame(uint id, Vector2 size)
	{
		ImGuiWindowFlags flags = ImGuiWindowFlags.None;
		return ImGuiNative.igBeginChildFrame(id, size, flags) != 0;
	}

	public static bool BeginChildFrame(uint id, Vector2 size, ImGuiWindowFlags flags)
	{
		return ImGuiNative.igBeginChildFrame(id, size, flags) != 0;
	}

	public unsafe static bool BeginCombo(string label, string preview_value)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (preview_value != null)
		{
			num2 = Encoding.UTF8.GetByteCount(preview_value);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(preview_value, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiComboFlags flags = ImGuiComboFlags.None;
		byte num3 = ImGuiNative.igBeginCombo(ptr, ptr2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
		return num3 != 0;
	}

	public unsafe static bool BeginCombo(string label, string preview_value, ImGuiComboFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (preview_value != null)
		{
			num2 = Encoding.UTF8.GetByteCount(preview_value);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(preview_value, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		byte num3 = ImGuiNative.igBeginCombo(ptr, ptr2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
		return num3 != 0;
	}

	public static void BeginDisabled()
	{
		ImGuiNative.igBeginDisabled(1);
	}

	public static void BeginDisabled(bool disabled)
	{
		ImGuiNative.igBeginDisabled((byte)(disabled ? 1 : 0));
	}

	public static bool BeginDragDropSource()
	{
		return ImGuiNative.igBeginDragDropSource(ImGuiDragDropFlags.None) != 0;
	}

	public static bool BeginDragDropSource(ImGuiDragDropFlags flags)
	{
		return ImGuiNative.igBeginDragDropSource(flags) != 0;
	}

	public static bool BeginDragDropTarget()
	{
		return ImGuiNative.igBeginDragDropTarget() != 0;
	}

	public static void BeginGroup()
	{
		ImGuiNative.igBeginGroup();
	}

	public unsafe static bool BeginListBox(string label)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igBeginListBox(ptr, default(Vector2));
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginListBox(string label, Vector2 size)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igBeginListBox(ptr, size);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public static bool BeginMainMenuBar()
	{
		return ImGuiNative.igBeginMainMenuBar() != 0;
	}

	public unsafe static bool BeginMenu(string label)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte enabled = 1;
		byte num2 = ImGuiNative.igBeginMenu(ptr, enabled);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginMenu(string label, bool enabled)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte enabled2 = (byte)(enabled ? 1 : 0);
		byte num2 = ImGuiNative.igBeginMenu(ptr, enabled2);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public static bool BeginMenuBar()
	{
		return ImGuiNative.igBeginMenuBar() != 0;
	}

	public unsafe static bool BeginPopup(string str_id)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiWindowFlags flags = ImGuiWindowFlags.None;
		byte num2 = ImGuiNative.igBeginPopup(ptr, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginPopup(string str_id, ImGuiWindowFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igBeginPopup(ptr, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginPopupContextItem()
	{
		byte* str_id = null;
		ImGuiPopupFlags popup_flags = ImGuiPopupFlags.MouseButtonRight;
		return ImGuiNative.igBeginPopupContextItem(str_id, popup_flags) != 0;
	}

	public unsafe static bool BeginPopupContextItem(string str_id)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiPopupFlags popup_flags = ImGuiPopupFlags.MouseButtonRight;
		byte num2 = ImGuiNative.igBeginPopupContextItem(ptr, popup_flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginPopupContextItem(string str_id, ImGuiPopupFlags popup_flags)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igBeginPopupContextItem(ptr, popup_flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginPopupContextVoid()
	{
		byte* str_id = null;
		ImGuiPopupFlags popup_flags = ImGuiPopupFlags.MouseButtonRight;
		return ImGuiNative.igBeginPopupContextVoid(str_id, popup_flags) != 0;
	}

	public unsafe static bool BeginPopupContextVoid(string str_id)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiPopupFlags popup_flags = ImGuiPopupFlags.MouseButtonRight;
		byte num2 = ImGuiNative.igBeginPopupContextVoid(ptr, popup_flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginPopupContextVoid(string str_id, ImGuiPopupFlags popup_flags)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igBeginPopupContextVoid(ptr, popup_flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginPopupContextWindow()
	{
		byte* str_id = null;
		ImGuiPopupFlags popup_flags = ImGuiPopupFlags.MouseButtonRight;
		return ImGuiNative.igBeginPopupContextWindow(str_id, popup_flags) != 0;
	}

	public unsafe static bool BeginPopupContextWindow(string str_id)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiPopupFlags popup_flags = ImGuiPopupFlags.MouseButtonRight;
		byte num2 = ImGuiNative.igBeginPopupContextWindow(ptr, popup_flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginPopupContextWindow(string str_id, ImGuiPopupFlags popup_flags)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igBeginPopupContextWindow(ptr, popup_flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginPopupModal(string name)
	{
		int num = 0;
		byte* ptr;
		if (name != null)
		{
			num = Encoding.UTF8.GetByteCount(name);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(name, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte* p_open = null;
		ImGuiWindowFlags flags = ImGuiWindowFlags.None;
		byte num2 = ImGuiNative.igBeginPopupModal(ptr, p_open, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginPopupModal(string name, ref bool p_open)
	{
		int num = 0;
		byte* ptr;
		if (name != null)
		{
			num = Encoding.UTF8.GetByteCount(name);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(name, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte b = (byte)(p_open ? 1 : 0);
		byte* p_open2 = &b;
		ImGuiWindowFlags flags = ImGuiWindowFlags.None;
		byte num2 = ImGuiNative.igBeginPopupModal(ptr, p_open2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		p_open = b != 0;
		return num2 != 0;
	}

	public unsafe static bool BeginPopupModal(string name, ref bool p_open, ImGuiWindowFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (name != null)
		{
			num = Encoding.UTF8.GetByteCount(name);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(name, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte b = (byte)(p_open ? 1 : 0);
		byte* p_open2 = &b;
		byte num2 = ImGuiNative.igBeginPopupModal(ptr, p_open2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		p_open = b != 0;
		return num2 != 0;
	}

	public unsafe static bool BeginTabBar(string str_id)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiTabBarFlags flags = ImGuiTabBarFlags.None;
		byte num2 = ImGuiNative.igBeginTabBar(ptr, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginTabBar(string str_id, ImGuiTabBarFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igBeginTabBar(ptr, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginTabItem(string label)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte* p_open = null;
		ImGuiTabItemFlags flags = ImGuiTabItemFlags.None;
		byte num2 = ImGuiNative.igBeginTabItem(ptr, p_open, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginTabItem(string label, ref bool p_open)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte b = (byte)(p_open ? 1 : 0);
		byte* p_open2 = &b;
		ImGuiTabItemFlags flags = ImGuiTabItemFlags.None;
		byte num2 = ImGuiNative.igBeginTabItem(ptr, p_open2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		p_open = b != 0;
		return num2 != 0;
	}

	public unsafe static bool BeginTabItem(string label, ref bool p_open, ImGuiTabItemFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte b = (byte)(p_open ? 1 : 0);
		byte* p_open2 = &b;
		byte num2 = ImGuiNative.igBeginTabItem(ptr, p_open2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		p_open = b != 0;
		return num2 != 0;
	}

	public unsafe static bool BeginTable(string str_id, int column)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiTableFlags flags = ImGuiTableFlags.None;
		Vector2 outer_size = default(Vector2);
		float inner_width = 0f;
		byte num2 = ImGuiNative.igBeginTable(ptr, column, flags, outer_size, inner_width);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginTable(string str_id, int column, ImGuiTableFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		Vector2 outer_size = default(Vector2);
		float inner_width = 0f;
		byte num2 = ImGuiNative.igBeginTable(ptr, column, flags, outer_size, inner_width);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginTable(string str_id, int column, ImGuiTableFlags flags, Vector2 outer_size)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float inner_width = 0f;
		byte num2 = ImGuiNative.igBeginTable(ptr, column, flags, outer_size, inner_width);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool BeginTable(string str_id, int column, ImGuiTableFlags flags, Vector2 outer_size, float inner_width)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igBeginTable(ptr, column, flags, outer_size, inner_width);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public static void BeginTooltip()
	{
		ImGuiNative.igBeginTooltip();
	}

	public static void Bullet()
	{
		ImGuiNative.igBullet();
	}

	public unsafe static void BulletText(string fmt)
	{
		int num = 0;
		byte* ptr;
		if (fmt != null)
		{
			num = Encoding.UTF8.GetByteCount(fmt);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(fmt, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igBulletText(ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static bool Button(string label)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igButton(ptr, default(Vector2));
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool Button(string label, Vector2 size)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igButton(ptr, size);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public static float CalcItemWidth()
	{
		return ImGuiNative.igCalcItemWidth();
	}

	public unsafe static bool Checkbox(string label, ref bool v)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte b = (byte)(v ? 1 : 0);
		byte* v2 = &b;
		byte num2 = ImGuiNative.igCheckbox(ptr, v2);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		v = b != 0;
		return num2 != 0;
	}

	public unsafe static bool CheckboxFlags(string label, ref int flags, int flags_value)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		fixed (int* flags2 = &flags)
		{
			byte num2 = ImGuiNative.igCheckboxFlags_IntPtr(ptr, flags2, flags_value);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return num2 != 0;
		}
	}

	public unsafe static bool CheckboxFlags(string label, ref uint flags, uint flags_value)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		fixed (uint* flags2 = &flags)
		{
			byte num2 = ImGuiNative.igCheckboxFlags_UintPtr(ptr, flags2, flags_value);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return num2 != 0;
		}
	}

	public static void CloseCurrentPopup()
	{
		ImGuiNative.igCloseCurrentPopup();
	}

	public unsafe static bool CollapsingHeader(string label)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags.None;
		byte num2 = ImGuiNative.igCollapsingHeader_TreeNodeFlags(ptr, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool CollapsingHeader(string label, ImGuiTreeNodeFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igCollapsingHeader_TreeNodeFlags(ptr, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool CollapsingHeader(string label, ref bool p_visible)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte b = (byte)(p_visible ? 1 : 0);
		byte* p_visible2 = &b;
		ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags.None;
		byte num2 = ImGuiNative.igCollapsingHeader_BoolPtr(ptr, p_visible2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		p_visible = b != 0;
		return num2 != 0;
	}

	public unsafe static bool CollapsingHeader(string label, ref bool p_visible, ImGuiTreeNodeFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte b = (byte)(p_visible ? 1 : 0);
		byte* p_visible2 = &b;
		byte num2 = ImGuiNative.igCollapsingHeader_BoolPtr(ptr, p_visible2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		p_visible = b != 0;
		return num2 != 0;
	}

	public unsafe static bool ColorButton(string desc_id, Vector4 col)
	{
		int num = 0;
		byte* ptr;
		if (desc_id != null)
		{
			num = Encoding.UTF8.GetByteCount(desc_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(desc_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiColorEditFlags flags = ImGuiColorEditFlags.None;
		byte num2 = ImGuiNative.igColorButton(ptr, col, flags, default(Vector2));
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool ColorButton(string desc_id, Vector4 col, ImGuiColorEditFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (desc_id != null)
		{
			num = Encoding.UTF8.GetByteCount(desc_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(desc_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igColorButton(ptr, col, flags, default(Vector2));
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool ColorButton(string desc_id, Vector4 col, ImGuiColorEditFlags flags, Vector2 size)
	{
		int num = 0;
		byte* ptr;
		if (desc_id != null)
		{
			num = Encoding.UTF8.GetByteCount(desc_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(desc_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igColorButton(ptr, col, flags, size);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public static uint ColorConvertFloat4ToU32(Vector4 @in)
	{
		return ImGuiNative.igColorConvertFloat4ToU32(@in);
	}

	public unsafe static void ColorConvertHSVtoRGB(float h, float s, float v, out float out_r, out float out_g, out float out_b)
	{
		fixed (float* out_r2 = &out_r)
		{
			fixed (float* out_g2 = &out_g)
			{
				fixed (float* out_b2 = &out_b)
				{
					ImGuiNative.igColorConvertHSVtoRGB(h, s, v, out_r2, out_g2, out_b2);
				}
			}
		}
	}

	public unsafe static void ColorConvertRGBtoHSV(float r, float g, float b, out float out_h, out float out_s, out float out_v)
	{
		fixed (float* out_h2 = &out_h)
		{
			fixed (float* out_s2 = &out_s)
			{
				fixed (float* out_v2 = &out_v)
				{
					ImGuiNative.igColorConvertRGBtoHSV(r, g, b, out_h2, out_s2, out_v2);
				}
			}
		}
	}

	public unsafe static Vector4 ColorConvertU32ToFloat4(uint @in)
	{
		Vector4 result = default(Vector4);
		ImGuiNative.igColorConvertU32ToFloat4(&result, @in);
		return result;
	}

	public unsafe static bool ColorEdit3(string label, ref Vector3 col)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiColorEditFlags flags = ImGuiColorEditFlags.None;
		fixed (Vector3* col2 = &col)
		{
			byte num2 = ImGuiNative.igColorEdit3(ptr, col2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return num2 != 0;
		}
	}

	public unsafe static bool ColorEdit3(string label, ref Vector3 col, ImGuiColorEditFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		fixed (Vector3* col2 = &col)
		{
			byte num2 = ImGuiNative.igColorEdit3(ptr, col2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return num2 != 0;
		}
	}

	public unsafe static bool ColorEdit4(string label, ref Vector4 col)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiColorEditFlags flags = ImGuiColorEditFlags.None;
		fixed (Vector4* col2 = &col)
		{
			byte num2 = ImGuiNative.igColorEdit4(ptr, col2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return num2 != 0;
		}
	}

	public unsafe static bool ColorEdit4(string label, ref Vector4 col, ImGuiColorEditFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		fixed (Vector4* col2 = &col)
		{
			byte num2 = ImGuiNative.igColorEdit4(ptr, col2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return num2 != 0;
		}
	}

	public unsafe static bool ColorPicker3(string label, ref Vector3 col)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiColorEditFlags flags = ImGuiColorEditFlags.None;
		fixed (Vector3* col2 = &col)
		{
			byte num2 = ImGuiNative.igColorPicker3(ptr, col2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return num2 != 0;
		}
	}

	public unsafe static bool ColorPicker3(string label, ref Vector3 col, ImGuiColorEditFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		fixed (Vector3* col2 = &col)
		{
			byte num2 = ImGuiNative.igColorPicker3(ptr, col2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return num2 != 0;
		}
	}

	public unsafe static bool ColorPicker4(string label, ref Vector4 col)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiColorEditFlags flags = ImGuiColorEditFlags.None;
		float* ref_col = null;
		fixed (Vector4* col2 = &col)
		{
			byte num2 = ImGuiNative.igColorPicker4(ptr, col2, flags, ref_col);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return num2 != 0;
		}
	}

	public unsafe static bool ColorPicker4(string label, ref Vector4 col, ImGuiColorEditFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float* ref_col = null;
		fixed (Vector4* col2 = &col)
		{
			byte num2 = ImGuiNative.igColorPicker4(ptr, col2, flags, ref_col);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return num2 != 0;
		}
	}

	public unsafe static bool ColorPicker4(string label, ref Vector4 col, ImGuiColorEditFlags flags, ref float ref_col)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		fixed (Vector4* col2 = &col)
		{
			fixed (float* ref_col2 = &ref_col)
			{
				byte num2 = ImGuiNative.igColorPicker4(ptr, col2, flags, ref_col2);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return num2 != 0;
			}
		}
	}

	public unsafe static void Columns()
	{
		byte* id = null;
		byte border = 1;
		ImGuiNative.igColumns(1, id, border);
	}

	public unsafe static void Columns(int count)
	{
		byte* id = null;
		byte border = 1;
		ImGuiNative.igColumns(count, id, border);
	}

	public unsafe static void Columns(int count, string id)
	{
		int num = 0;
		byte* ptr;
		if (id != null)
		{
			num = Encoding.UTF8.GetByteCount(id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte border = 1;
		ImGuiNative.igColumns(count, ptr, border);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static void Columns(int count, string id, bool border)
	{
		int num = 0;
		byte* ptr;
		if (id != null)
		{
			num = Encoding.UTF8.GetByteCount(id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte border2 = (byte)(border ? 1 : 0);
		ImGuiNative.igColumns(count, ptr, border2);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static bool Combo(string label, ref int current_item, string[] items, int items_count)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int* ptr2 = stackalloc int[items.Length];
		int num2 = 0;
		for (int i = 0; i < items.Length; i++)
		{
			string s = items[i];
			ptr2[i] = Encoding.UTF8.GetByteCount(s);
			num2 += ptr2[i] + 1;
		}
		byte* ptr3 = stackalloc byte[(int)(uint)num2];
		int num3 = 0;
		for (int j = 0; j < items.Length; j++)
		{
			string text = items[j];
			fixed (char* chars = text)
			{
				num3 += Encoding.UTF8.GetBytes(chars, text.Length, ptr3 + num3, ptr2[j]);
				ptr3[num3] = 0;
				num3++;
			}
		}
		byte** ptr4 = stackalloc byte*[items.Length];
		num3 = 0;
		for (int k = 0; k < items.Length; k++)
		{
			ptr4[k] = ptr3 + num3;
			num3 += ptr2[k] + 1;
		}
		int popup_max_height_in_items = -1;
		fixed (int* current_item2 = &current_item)
		{
			byte num4 = ImGuiNative.igCombo_Str_arr(ptr, current_item2, ptr4, items_count, popup_max_height_in_items);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return num4 != 0;
		}
	}

	public unsafe static bool Combo(string label, ref int current_item, string[] items, int items_count, int popup_max_height_in_items)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int* ptr2 = stackalloc int[items.Length];
		int num2 = 0;
		for (int i = 0; i < items.Length; i++)
		{
			string s = items[i];
			ptr2[i] = Encoding.UTF8.GetByteCount(s);
			num2 += ptr2[i] + 1;
		}
		byte* ptr3 = stackalloc byte[(int)(uint)num2];
		int num3 = 0;
		for (int j = 0; j < items.Length; j++)
		{
			string text = items[j];
			fixed (char* chars = text)
			{
				num3 += Encoding.UTF8.GetBytes(chars, text.Length, ptr3 + num3, ptr2[j]);
				ptr3[num3] = 0;
				num3++;
			}
		}
		byte** ptr4 = stackalloc byte*[items.Length];
		num3 = 0;
		for (int k = 0; k < items.Length; k++)
		{
			ptr4[k] = ptr3 + num3;
			num3 += ptr2[k] + 1;
		}
		fixed (int* current_item2 = &current_item)
		{
			byte num4 = ImGuiNative.igCombo_Str_arr(ptr, current_item2, ptr4, items_count, popup_max_height_in_items);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return num4 != 0;
		}
	}

	public unsafe static bool Combo(string label, ref int current_item, string items_separated_by_zeros)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (items_separated_by_zeros != null)
		{
			num2 = Encoding.UTF8.GetByteCount(items_separated_by_zeros);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(items_separated_by_zeros, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		int popup_max_height_in_items = -1;
		fixed (int* current_item2 = &current_item)
		{
			byte num3 = ImGuiNative.igCombo_Str(ptr, current_item2, ptr2, popup_max_height_in_items);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool Combo(string label, ref int current_item, string items_separated_by_zeros, int popup_max_height_in_items)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (items_separated_by_zeros != null)
		{
			num2 = Encoding.UTF8.GetByteCount(items_separated_by_zeros);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(items_separated_by_zeros, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (int* current_item2 = &current_item)
		{
			byte num3 = ImGuiNative.igCombo_Str(ptr, current_item2, ptr2, popup_max_height_in_items);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static IntPtr CreateContext()
	{
		ImFontAtlas* shared_font_atlas = null;
		return ImGuiNative.igCreateContext(shared_font_atlas);
	}

	public unsafe static IntPtr CreateContext(ImFontAtlasPtr shared_font_atlas)
	{
		return ImGuiNative.igCreateContext(shared_font_atlas.NativePtr);
	}

	public unsafe static bool DebugCheckVersionAndDataLayout(string version_str, uint sz_io, uint sz_style, uint sz_vec2, uint sz_vec4, uint sz_drawvert, uint sz_drawidx)
	{
		int num = 0;
		byte* ptr;
		if (version_str != null)
		{
			num = Encoding.UTF8.GetByteCount(version_str);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(version_str, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igDebugCheckVersionAndDataLayout(ptr, sz_io, sz_style, sz_vec2, sz_vec4, sz_drawvert, sz_drawidx);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static void DebugTextEncoding(string text)
	{
		int num = 0;
		byte* ptr;
		if (text != null)
		{
			num = Encoding.UTF8.GetByteCount(text);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(text, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igDebugTextEncoding(ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public static void DestroyContext()
	{
		ImGuiNative.igDestroyContext(IntPtr.Zero);
	}

	public static void DestroyContext(IntPtr ctx)
	{
		ImGuiNative.igDestroyContext(ctx);
	}

	public static void DestroyPlatformWindows()
	{
		ImGuiNative.igDestroyPlatformWindows();
	}

	public unsafe static uint DockSpace(uint id)
	{
		Vector2 size = default(Vector2);
		ImGuiDockNodeFlags flags = ImGuiDockNodeFlags.None;
		ImGuiWindowClass* window_class = null;
		return ImGuiNative.igDockSpace(id, size, flags, window_class);
	}

	public unsafe static uint DockSpace(uint id, Vector2 size)
	{
		ImGuiDockNodeFlags flags = ImGuiDockNodeFlags.None;
		ImGuiWindowClass* window_class = null;
		return ImGuiNative.igDockSpace(id, size, flags, window_class);
	}

	public unsafe static uint DockSpace(uint id, Vector2 size, ImGuiDockNodeFlags flags)
	{
		ImGuiWindowClass* window_class = null;
		return ImGuiNative.igDockSpace(id, size, flags, window_class);
	}

	public unsafe static uint DockSpace(uint id, Vector2 size, ImGuiDockNodeFlags flags, ImGuiWindowClassPtr window_class)
	{
		ImGuiWindowClass* nativePtr = window_class.NativePtr;
		return ImGuiNative.igDockSpace(id, size, flags, nativePtr);
	}

	public unsafe static uint DockSpaceOverViewport()
	{
		ImGuiViewport* viewport = null;
		ImGuiDockNodeFlags flags = ImGuiDockNodeFlags.None;
		ImGuiWindowClass* window_class = null;
		return ImGuiNative.igDockSpaceOverViewport(viewport, flags, window_class);
	}

	public unsafe static uint DockSpaceOverViewport(ImGuiViewportPtr viewport)
	{
		ImGuiViewport* nativePtr = viewport.NativePtr;
		ImGuiDockNodeFlags flags = ImGuiDockNodeFlags.None;
		ImGuiWindowClass* window_class = null;
		return ImGuiNative.igDockSpaceOverViewport(nativePtr, flags, window_class);
	}

	public unsafe static uint DockSpaceOverViewport(ImGuiViewportPtr viewport, ImGuiDockNodeFlags flags)
	{
		ImGuiViewport* nativePtr = viewport.NativePtr;
		ImGuiWindowClass* window_class = null;
		return ImGuiNative.igDockSpaceOverViewport(nativePtr, flags, window_class);
	}

	public unsafe static uint DockSpaceOverViewport(ImGuiViewportPtr viewport, ImGuiDockNodeFlags flags, ImGuiWindowClassPtr window_class)
	{
		ImGuiViewport* nativePtr = viewport.NativePtr;
		ImGuiWindowClass* nativePtr2 = window_class.NativePtr;
		return ImGuiNative.igDockSpaceOverViewport(nativePtr, flags, nativePtr2);
	}

	public unsafe static bool DragFloat(string label, ref float v)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float v_speed = 1f;
		float v_min = 0f;
		float v_max = 0f;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (float* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragFloat(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragFloat(string label, ref float v, float v_speed)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float v_min = 0f;
		float v_max = 0f;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (float* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragFloat(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragFloat(string label, ref float v, float v_speed, float v_min)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float v_max = 0f;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (float* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragFloat(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragFloat(string label, ref float v, float v_speed, float v_min, float v_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (float* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragFloat(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragFloat(string label, ref float v, float v_speed, float v_min, float v_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (float* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragFloat(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragFloat(string label, ref float v, float v_speed, float v_min, float v_max, string format, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (float* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragFloat(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragFloat2(string label, ref Vector2 v)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float v_speed = 1f;
		float v_min = 0f;
		float v_max = 0f;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (Vector2* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragFloat2(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragFloat2(string label, ref Vector2 v, float v_speed)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float v_min = 0f;
		float v_max = 0f;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (Vector2* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragFloat2(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragFloat2(string label, ref Vector2 v, float v_speed, float v_min)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float v_max = 0f;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (Vector2* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragFloat2(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragFloat2(string label, ref Vector2 v, float v_speed, float v_min, float v_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (Vector2* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragFloat2(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragFloat2(string label, ref Vector2 v, float v_speed, float v_min, float v_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (Vector2* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragFloat2(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragFloat2(string label, ref Vector2 v, float v_speed, float v_min, float v_max, string format, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (Vector2* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragFloat2(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragFloat3(string label, ref Vector3 v)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float v_speed = 1f;
		float v_min = 0f;
		float v_max = 0f;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (Vector3* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragFloat3(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragFloat3(string label, ref Vector3 v, float v_speed)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float v_min = 0f;
		float v_max = 0f;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (Vector3* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragFloat3(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragFloat3(string label, ref Vector3 v, float v_speed, float v_min)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float v_max = 0f;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (Vector3* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragFloat3(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragFloat3(string label, ref Vector3 v, float v_speed, float v_min, float v_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (Vector3* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragFloat3(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragFloat3(string label, ref Vector3 v, float v_speed, float v_min, float v_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (Vector3* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragFloat3(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragFloat3(string label, ref Vector3 v, float v_speed, float v_min, float v_max, string format, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (Vector3* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragFloat3(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragFloat4(string label, ref Vector4 v)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float v_speed = 1f;
		float v_min = 0f;
		float v_max = 0f;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (Vector4* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragFloat4(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragFloat4(string label, ref Vector4 v, float v_speed)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float v_min = 0f;
		float v_max = 0f;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (Vector4* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragFloat4(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragFloat4(string label, ref Vector4 v, float v_speed, float v_min)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float v_max = 0f;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (Vector4* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragFloat4(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragFloat4(string label, ref Vector4 v, float v_speed, float v_min, float v_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (Vector4* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragFloat4(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragFloat4(string label, ref Vector4 v, float v_speed, float v_min, float v_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (Vector4* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragFloat4(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragFloat4(string label, ref Vector4 v, float v_speed, float v_min, float v_max, string format, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (Vector4* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragFloat4(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragFloatRange2(string label, ref float v_current_min, ref float v_current_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float v_speed = 1f;
		float v_min = 0f;
		float v_max = 0f;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		byte* format_max = null;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (float* v_current_min2 = &v_current_min)
		{
			fixed (float* v_current_max2 = &v_current_max)
			{
				byte num3 = ImGuiNative.igDragFloatRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr2, format_max, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr2);
				}
				return num3 != 0;
			}
		}
	}

	public unsafe static bool DragFloatRange2(string label, ref float v_current_min, ref float v_current_max, float v_speed)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float v_min = 0f;
		float v_max = 0f;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		byte* format_max = null;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (float* v_current_min2 = &v_current_min)
		{
			fixed (float* v_current_max2 = &v_current_max)
			{
				byte num3 = ImGuiNative.igDragFloatRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr2, format_max, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr2);
				}
				return num3 != 0;
			}
		}
	}

	public unsafe static bool DragFloatRange2(string label, ref float v_current_min, ref float v_current_max, float v_speed, float v_min)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float v_max = 0f;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		byte* format_max = null;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (float* v_current_min2 = &v_current_min)
		{
			fixed (float* v_current_max2 = &v_current_max)
			{
				byte num3 = ImGuiNative.igDragFloatRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr2, format_max, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr2);
				}
				return num3 != 0;
			}
		}
	}

	public unsafe static bool DragFloatRange2(string label, ref float v_current_min, ref float v_current_max, float v_speed, float v_min, float v_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		byte* format_max = null;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (float* v_current_min2 = &v_current_min)
		{
			fixed (float* v_current_max2 = &v_current_max)
			{
				byte num3 = ImGuiNative.igDragFloatRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr2, format_max, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr2);
				}
				return num3 != 0;
			}
		}
	}

	public unsafe static bool DragFloatRange2(string label, ref float v_current_min, ref float v_current_max, float v_speed, float v_min, float v_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		byte* format_max = null;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (float* v_current_min2 = &v_current_min)
		{
			fixed (float* v_current_max2 = &v_current_max)
			{
				byte num3 = ImGuiNative.igDragFloatRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr2, format_max, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr2);
				}
				return num3 != 0;
			}
		}
	}

	public unsafe static bool DragFloatRange2(string label, ref float v_current_min, ref float v_current_max, float v_speed, float v_min, float v_max, string format, string format_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		int num3 = 0;
		byte* ptr3;
		if (format_max != null)
		{
			num3 = Encoding.UTF8.GetByteCount(format_max);
			ptr3 = ((num3 <= 2048) ? stackalloc byte[(int)(uint)(num3 + 1)] : Util.Allocate(num3 + 1));
			int utf3 = Util.GetUtf8(format_max, ptr3, num3);
			ptr3[utf3] = 0;
		}
		else
		{
			ptr3 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (float* v_current_min2 = &v_current_min)
		{
			fixed (float* v_current_max2 = &v_current_max)
			{
				byte num4 = ImGuiNative.igDragFloatRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr2, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr2);
				}
				if (num3 > 2048)
				{
					Util.Free(ptr3);
				}
				return num4 != 0;
			}
		}
	}

	public unsafe static bool DragFloatRange2(string label, ref float v_current_min, ref float v_current_max, float v_speed, float v_min, float v_max, string format, string format_max, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		int num3 = 0;
		byte* ptr3;
		if (format_max != null)
		{
			num3 = Encoding.UTF8.GetByteCount(format_max);
			ptr3 = ((num3 <= 2048) ? stackalloc byte[(int)(uint)(num3 + 1)] : Util.Allocate(num3 + 1));
			int utf3 = Util.GetUtf8(format_max, ptr3, num3);
			ptr3[utf3] = 0;
		}
		else
		{
			ptr3 = null;
		}
		fixed (float* v_current_min2 = &v_current_min)
		{
			fixed (float* v_current_max2 = &v_current_max)
			{
				byte num4 = ImGuiNative.igDragFloatRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr2, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr2);
				}
				if (num3 > 2048)
				{
					Util.Free(ptr3);
				}
				return num4 != 0;
			}
		}
	}

	public unsafe static bool DragInt(string label, ref int v)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float v_speed = 1f;
		int v_min = 0;
		int v_max = 0;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%d");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%d", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragInt(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragInt(string label, ref int v, float v_speed)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int v_min = 0;
		int v_max = 0;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%d");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%d", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragInt(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragInt(string label, ref int v, float v_speed, int v_min)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int v_max = 0;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%d");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%d", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragInt(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragInt(string label, ref int v, float v_speed, int v_min, int v_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%d");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%d", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragInt(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragInt(string label, ref int v, float v_speed, int v_min, int v_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragInt(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragInt(string label, ref int v, float v_speed, int v_min, int v_max, string format, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragInt(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragInt2(string label, ref int v)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float v_speed = 1f;
		int v_min = 0;
		int v_max = 0;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%d");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%d", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragInt2(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragInt2(string label, ref int v, float v_speed)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int v_min = 0;
		int v_max = 0;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%d");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%d", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragInt2(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragInt2(string label, ref int v, float v_speed, int v_min)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int v_max = 0;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%d");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%d", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragInt2(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragInt2(string label, ref int v, float v_speed, int v_min, int v_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%d");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%d", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragInt2(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragInt2(string label, ref int v, float v_speed, int v_min, int v_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragInt2(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragInt2(string label, ref int v, float v_speed, int v_min, int v_max, string format, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragInt2(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragInt3(string label, ref int v)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float v_speed = 1f;
		int v_min = 0;
		int v_max = 0;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%d");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%d", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragInt3(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragInt3(string label, ref int v, float v_speed)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int v_min = 0;
		int v_max = 0;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%d");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%d", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragInt3(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragInt3(string label, ref int v, float v_speed, int v_min)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int v_max = 0;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%d");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%d", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragInt3(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragInt3(string label, ref int v, float v_speed, int v_min, int v_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%d");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%d", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragInt3(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragInt3(string label, ref int v, float v_speed, int v_min, int v_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragInt3(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragInt3(string label, ref int v, float v_speed, int v_min, int v_max, string format, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragInt3(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragInt4(string label, ref int v)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float v_speed = 1f;
		int v_min = 0;
		int v_max = 0;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%d");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%d", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragInt4(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragInt4(string label, ref int v, float v_speed)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int v_min = 0;
		int v_max = 0;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%d");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%d", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragInt4(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragInt4(string label, ref int v, float v_speed, int v_min)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int v_max = 0;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%d");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%d", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragInt4(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragInt4(string label, ref int v, float v_speed, int v_min, int v_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%d");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%d", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragInt4(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragInt4(string label, ref int v, float v_speed, int v_min, int v_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragInt4(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragInt4(string label, ref int v, float v_speed, int v_min, int v_max, string format, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igDragInt4(ptr, v2, v_speed, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool DragIntRange2(string label, ref int v_current_min, ref int v_current_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float v_speed = 1f;
		int v_min = 0;
		int v_max = 0;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%d");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%d", ptr2, num2);
		ptr2[utf2] = 0;
		byte* format_max = null;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v_current_min2 = &v_current_min)
		{
			fixed (int* v_current_max2 = &v_current_max)
			{
				byte num3 = ImGuiNative.igDragIntRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr2, format_max, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr2);
				}
				return num3 != 0;
			}
		}
	}

	public unsafe static bool DragIntRange2(string label, ref int v_current_min, ref int v_current_max, float v_speed)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int v_min = 0;
		int v_max = 0;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%d");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%d", ptr2, num2);
		ptr2[utf2] = 0;
		byte* format_max = null;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v_current_min2 = &v_current_min)
		{
			fixed (int* v_current_max2 = &v_current_max)
			{
				byte num3 = ImGuiNative.igDragIntRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr2, format_max, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr2);
				}
				return num3 != 0;
			}
		}
	}

	public unsafe static bool DragIntRange2(string label, ref int v_current_min, ref int v_current_max, float v_speed, int v_min)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int v_max = 0;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%d");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%d", ptr2, num2);
		ptr2[utf2] = 0;
		byte* format_max = null;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v_current_min2 = &v_current_min)
		{
			fixed (int* v_current_max2 = &v_current_max)
			{
				byte num3 = ImGuiNative.igDragIntRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr2, format_max, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr2);
				}
				return num3 != 0;
			}
		}
	}

	public unsafe static bool DragIntRange2(string label, ref int v_current_min, ref int v_current_max, float v_speed, int v_min, int v_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%d");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%d", ptr2, num2);
		ptr2[utf2] = 0;
		byte* format_max = null;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v_current_min2 = &v_current_min)
		{
			fixed (int* v_current_max2 = &v_current_max)
			{
				byte num3 = ImGuiNative.igDragIntRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr2, format_max, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr2);
				}
				return num3 != 0;
			}
		}
	}

	public unsafe static bool DragIntRange2(string label, ref int v_current_min, ref int v_current_max, float v_speed, int v_min, int v_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		byte* format_max = null;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v_current_min2 = &v_current_min)
		{
			fixed (int* v_current_max2 = &v_current_max)
			{
				byte num3 = ImGuiNative.igDragIntRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr2, format_max, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr2);
				}
				return num3 != 0;
			}
		}
	}

	public unsafe static bool DragIntRange2(string label, ref int v_current_min, ref int v_current_max, float v_speed, int v_min, int v_max, string format, string format_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		int num3 = 0;
		byte* ptr3;
		if (format_max != null)
		{
			num3 = Encoding.UTF8.GetByteCount(format_max);
			ptr3 = ((num3 <= 2048) ? stackalloc byte[(int)(uint)(num3 + 1)] : Util.Allocate(num3 + 1));
			int utf3 = Util.GetUtf8(format_max, ptr3, num3);
			ptr3[utf3] = 0;
		}
		else
		{
			ptr3 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v_current_min2 = &v_current_min)
		{
			fixed (int* v_current_max2 = &v_current_max)
			{
				byte num4 = ImGuiNative.igDragIntRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr2, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr2);
				}
				if (num3 > 2048)
				{
					Util.Free(ptr3);
				}
				return num4 != 0;
			}
		}
	}

	public unsafe static bool DragIntRange2(string label, ref int v_current_min, ref int v_current_max, float v_speed, int v_min, int v_max, string format, string format_max, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		int num3 = 0;
		byte* ptr3;
		if (format_max != null)
		{
			num3 = Encoding.UTF8.GetByteCount(format_max);
			ptr3 = ((num3 <= 2048) ? stackalloc byte[(int)(uint)(num3 + 1)] : Util.Allocate(num3 + 1));
			int utf3 = Util.GetUtf8(format_max, ptr3, num3);
			ptr3[utf3] = 0;
		}
		else
		{
			ptr3 = null;
		}
		fixed (int* v_current_min2 = &v_current_min)
		{
			fixed (int* v_current_max2 = &v_current_max)
			{
				byte num4 = ImGuiNative.igDragIntRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr2, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr2);
				}
				if (num3 > 2048)
				{
					Util.Free(ptr3);
				}
				return num4 != 0;
			}
		}
	}

	public unsafe static bool DragScalar(string label, ImGuiDataType data_type, IntPtr p_data)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		float v_speed = 1f;
		void* p_min = null;
		void* p_max = null;
		byte* format = null;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		byte num2 = ImGuiNative.igDragScalar(ptr, data_type, p_data2, v_speed, p_min, p_max, format, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool DragScalar(string label, ImGuiDataType data_type, IntPtr p_data, float v_speed)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_min = null;
		void* p_max = null;
		byte* format = null;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		byte num2 = ImGuiNative.igDragScalar(ptr, data_type, p_data2, v_speed, p_min, p_max, format, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool DragScalar(string label, ImGuiDataType data_type, IntPtr p_data, float v_speed, IntPtr p_min)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_min2 = p_min.ToPointer();
		void* p_max = null;
		byte* format = null;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		byte num2 = ImGuiNative.igDragScalar(ptr, data_type, p_data2, v_speed, p_min2, p_max, format, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool DragScalar(string label, ImGuiDataType data_type, IntPtr p_data, float v_speed, IntPtr p_min, IntPtr p_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_min2 = p_min.ToPointer();
		void* p_max2 = p_max.ToPointer();
		byte* format = null;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		byte num2 = ImGuiNative.igDragScalar(ptr, data_type, p_data2, v_speed, p_min2, p_max2, format, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool DragScalar(string label, ImGuiDataType data_type, IntPtr p_data, float v_speed, IntPtr p_min, IntPtr p_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_min2 = p_min.ToPointer();
		void* p_max2 = p_max.ToPointer();
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		byte num3 = ImGuiNative.igDragScalar(ptr, data_type, p_data2, v_speed, p_min2, p_max2, ptr2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
		return num3 != 0;
	}

	public unsafe static bool DragScalar(string label, ImGuiDataType data_type, IntPtr p_data, float v_speed, IntPtr p_min, IntPtr p_max, string format, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_min2 = p_min.ToPointer();
		void* p_max2 = p_max.ToPointer();
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		byte num3 = ImGuiNative.igDragScalar(ptr, data_type, p_data2, v_speed, p_min2, p_max2, ptr2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
		return num3 != 0;
	}

	public unsafe static bool DragScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		float v_speed = 1f;
		void* p_min = null;
		void* p_max = null;
		byte* format = null;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		byte num2 = ImGuiNative.igDragScalarN(ptr, data_type, p_data2, components, v_speed, p_min, p_max, format, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool DragScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components, float v_speed)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_min = null;
		void* p_max = null;
		byte* format = null;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		byte num2 = ImGuiNative.igDragScalarN(ptr, data_type, p_data2, components, v_speed, p_min, p_max, format, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool DragScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components, float v_speed, IntPtr p_min)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_min2 = p_min.ToPointer();
		void* p_max = null;
		byte* format = null;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		byte num2 = ImGuiNative.igDragScalarN(ptr, data_type, p_data2, components, v_speed, p_min2, p_max, format, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool DragScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components, float v_speed, IntPtr p_min, IntPtr p_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_min2 = p_min.ToPointer();
		void* p_max2 = p_max.ToPointer();
		byte* format = null;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		byte num2 = ImGuiNative.igDragScalarN(ptr, data_type, p_data2, components, v_speed, p_min2, p_max2, format, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool DragScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components, float v_speed, IntPtr p_min, IntPtr p_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_min2 = p_min.ToPointer();
		void* p_max2 = p_max.ToPointer();
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		byte num3 = ImGuiNative.igDragScalarN(ptr, data_type, p_data2, components, v_speed, p_min2, p_max2, ptr2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
		return num3 != 0;
	}

	public unsafe static bool DragScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components, float v_speed, IntPtr p_min, IntPtr p_max, string format, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_min2 = p_min.ToPointer();
		void* p_max2 = p_max.ToPointer();
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		byte num3 = ImGuiNative.igDragScalarN(ptr, data_type, p_data2, components, v_speed, p_min2, p_max2, ptr2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
		return num3 != 0;
	}

	public static void Dummy(Vector2 size)
	{
		ImGuiNative.igDummy(size);
	}

	public static void End()
	{
		ImGuiNative.igEnd();
	}

	public static void EndChild()
	{
		ImGuiNative.igEndChild();
	}

	public static void EndChildFrame()
	{
		ImGuiNative.igEndChildFrame();
	}

	public static void EndCombo()
	{
		ImGuiNative.igEndCombo();
	}

	public static void EndDisabled()
	{
		ImGuiNative.igEndDisabled();
	}

	public static void EndDragDropSource()
	{
		ImGuiNative.igEndDragDropSource();
	}

	public static void EndDragDropTarget()
	{
		ImGuiNative.igEndDragDropTarget();
	}

	public static void EndFrame()
	{
		ImGuiNative.igEndFrame();
	}

	public static void EndGroup()
	{
		ImGuiNative.igEndGroup();
	}

	public static void EndListBox()
	{
		ImGuiNative.igEndListBox();
	}

	public static void EndMainMenuBar()
	{
		ImGuiNative.igEndMainMenuBar();
	}

	public static void EndMenu()
	{
		ImGuiNative.igEndMenu();
	}

	public static void EndMenuBar()
	{
		ImGuiNative.igEndMenuBar();
	}

	public static void EndPopup()
	{
		ImGuiNative.igEndPopup();
	}

	public static void EndTabBar()
	{
		ImGuiNative.igEndTabBar();
	}

	public static void EndTabItem()
	{
		ImGuiNative.igEndTabItem();
	}

	public static void EndTable()
	{
		ImGuiNative.igEndTable();
	}

	public static void EndTooltip()
	{
		ImGuiNative.igEndTooltip();
	}

	public unsafe static ImGuiViewportPtr FindViewportByID(uint id)
	{
		return new ImGuiViewportPtr(ImGuiNative.igFindViewportByID(id));
	}

	public unsafe static ImGuiViewportPtr FindViewportByPlatformHandle(IntPtr platform_handle)
	{
		return new ImGuiViewportPtr(ImGuiNative.igFindViewportByPlatformHandle(platform_handle.ToPointer()));
	}

	public unsafe static void GetAllocatorFunctions(ref IntPtr p_alloc_func, ref IntPtr p_free_func, ref void* p_user_data)
	{
		fixed (IntPtr* p_alloc_func2 = &p_alloc_func)
		{
			fixed (IntPtr* p_free_func2 = &p_free_func)
			{
				fixed (void** p_user_data2 = &p_user_data)
				{
					ImGuiNative.igGetAllocatorFunctions(p_alloc_func2, p_free_func2, p_user_data2);
				}
			}
		}
	}

	public unsafe static ImDrawListPtr GetBackgroundDrawList()
	{
		return new ImDrawListPtr(ImGuiNative.igGetBackgroundDrawList_Nil());
	}

	public unsafe static ImDrawListPtr GetBackgroundDrawList(ImGuiViewportPtr viewport)
	{
		return new ImDrawListPtr(ImGuiNative.igGetBackgroundDrawList_ViewportPtr(viewport.NativePtr));
	}

	public unsafe static string GetClipboardText()
	{
		return Util.StringFromPtr(ImGuiNative.igGetClipboardText());
	}

	public static uint GetColorU32(ImGuiCol idx)
	{
		float alpha_mul = 1f;
		return ImGuiNative.igGetColorU32_Col(idx, alpha_mul);
	}

	public static uint GetColorU32(ImGuiCol idx, float alpha_mul)
	{
		return ImGuiNative.igGetColorU32_Col(idx, alpha_mul);
	}

	public static uint GetColorU32(Vector4 col)
	{
		return ImGuiNative.igGetColorU32_Vec4(col);
	}

	public static uint GetColorU32(uint col)
	{
		return ImGuiNative.igGetColorU32_U32(col);
	}

	public static int GetColumnIndex()
	{
		return ImGuiNative.igGetColumnIndex();
	}

	public static float GetColumnOffset()
	{
		return ImGuiNative.igGetColumnOffset(-1);
	}

	public static float GetColumnOffset(int column_index)
	{
		return ImGuiNative.igGetColumnOffset(column_index);
	}

	public static int GetColumnsCount()
	{
		return ImGuiNative.igGetColumnsCount();
	}

	public static float GetColumnWidth()
	{
		return ImGuiNative.igGetColumnWidth(-1);
	}

	public static float GetColumnWidth(int column_index)
	{
		return ImGuiNative.igGetColumnWidth(column_index);
	}

	public unsafe static Vector2 GetContentRegionAvail()
	{
		Vector2 result = default(Vector2);
		ImGuiNative.igGetContentRegionAvail(&result);
		return result;
	}

	public unsafe static Vector2 GetContentRegionMax()
	{
		Vector2 result = default(Vector2);
		ImGuiNative.igGetContentRegionMax(&result);
		return result;
	}

	public static IntPtr GetCurrentContext()
	{
		return ImGuiNative.igGetCurrentContext();
	}

	public unsafe static Vector2 GetCursorPos()
	{
		Vector2 result = default(Vector2);
		ImGuiNative.igGetCursorPos(&result);
		return result;
	}

	public static float GetCursorPosX()
	{
		return ImGuiNative.igGetCursorPosX();
	}

	public static float GetCursorPosY()
	{
		return ImGuiNative.igGetCursorPosY();
	}

	public unsafe static Vector2 GetCursorScreenPos()
	{
		Vector2 result = default(Vector2);
		ImGuiNative.igGetCursorScreenPos(&result);
		return result;
	}

	public unsafe static Vector2 GetCursorStartPos()
	{
		Vector2 result = default(Vector2);
		ImGuiNative.igGetCursorStartPos(&result);
		return result;
	}

	public unsafe static ImGuiPayloadPtr GetDragDropPayload()
	{
		return new ImGuiPayloadPtr(ImGuiNative.igGetDragDropPayload());
	}

	public unsafe static ImDrawDataPtr GetDrawData()
	{
		return new ImDrawDataPtr(ImGuiNative.igGetDrawData());
	}

	public static IntPtr GetDrawListSharedData()
	{
		return ImGuiNative.igGetDrawListSharedData();
	}

	public unsafe static ImFontPtr GetFont()
	{
		return new ImFontPtr(ImGuiNative.igGetFont());
	}

	public static float GetFontSize()
	{
		return ImGuiNative.igGetFontSize();
	}

	public unsafe static Vector2 GetFontTexUvWhitePixel()
	{
		Vector2 result = default(Vector2);
		ImGuiNative.igGetFontTexUvWhitePixel(&result);
		return result;
	}

	public unsafe static ImDrawListPtr GetForegroundDrawList()
	{
		return new ImDrawListPtr(ImGuiNative.igGetForegroundDrawList_Nil());
	}

	public unsafe static ImDrawListPtr GetForegroundDrawList(ImGuiViewportPtr viewport)
	{
		return new ImDrawListPtr(ImGuiNative.igGetForegroundDrawList_ViewportPtr(viewport.NativePtr));
	}

	public static int GetFrameCount()
	{
		return ImGuiNative.igGetFrameCount();
	}

	public static float GetFrameHeight()
	{
		return ImGuiNative.igGetFrameHeight();
	}

	public static float GetFrameHeightWithSpacing()
	{
		return ImGuiNative.igGetFrameHeightWithSpacing();
	}

	public unsafe static uint GetID(string str_id)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		uint result = ImGuiNative.igGetID_Str(ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return result;
	}

	public unsafe static uint GetID(IntPtr ptr_id)
	{
		return ImGuiNative.igGetID_Ptr(ptr_id.ToPointer());
	}

	public unsafe static ImGuiIOPtr GetIO()
	{
		return new ImGuiIOPtr(ImGuiNative.igGetIO());
	}

	public unsafe static Vector2 GetItemRectMax()
	{
		Vector2 result = default(Vector2);
		ImGuiNative.igGetItemRectMax(&result);
		return result;
	}

	public unsafe static Vector2 GetItemRectMin()
	{
		Vector2 result = default(Vector2);
		ImGuiNative.igGetItemRectMin(&result);
		return result;
	}

	public unsafe static Vector2 GetItemRectSize()
	{
		Vector2 result = default(Vector2);
		ImGuiNative.igGetItemRectSize(&result);
		return result;
	}

	public static ImGuiKey GetKeyIndex(ImGuiKey key)
	{
		return ImGuiNative.igGetKeyIndex(key);
	}

	public unsafe static string GetKeyName(ImGuiKey key)
	{
		return Util.StringFromPtr(ImGuiNative.igGetKeyName(key));
	}

	public static int GetKeyPressedAmount(ImGuiKey key, float repeat_delay, float rate)
	{
		return ImGuiNative.igGetKeyPressedAmount(key, repeat_delay, rate);
	}

	public unsafe static ImGuiViewportPtr GetMainViewport()
	{
		return new ImGuiViewportPtr(ImGuiNative.igGetMainViewport());
	}

	public static int GetMouseClickedCount(ImGuiMouseButton button)
	{
		return ImGuiNative.igGetMouseClickedCount(button);
	}

	public static ImGuiMouseCursor GetMouseCursor()
	{
		return ImGuiNative.igGetMouseCursor();
	}

	public unsafe static Vector2 GetMouseDragDelta()
	{
		ImGuiMouseButton button = ImGuiMouseButton.Left;
		float lock_threshold = -1f;
		Vector2 result = default(Vector2);
		ImGuiNative.igGetMouseDragDelta(&result, button, lock_threshold);
		return result;
	}

	public unsafe static Vector2 GetMouseDragDelta(ImGuiMouseButton button)
	{
		float lock_threshold = -1f;
		Vector2 result = default(Vector2);
		ImGuiNative.igGetMouseDragDelta(&result, button, lock_threshold);
		return result;
	}

	public unsafe static Vector2 GetMouseDragDelta(ImGuiMouseButton button, float lock_threshold)
	{
		Vector2 result = default(Vector2);
		ImGuiNative.igGetMouseDragDelta(&result, button, lock_threshold);
		return result;
	}

	public unsafe static Vector2 GetMousePos()
	{
		Vector2 result = default(Vector2);
		ImGuiNative.igGetMousePos(&result);
		return result;
	}

	public unsafe static Vector2 GetMousePosOnOpeningCurrentPopup()
	{
		Vector2 result = default(Vector2);
		ImGuiNative.igGetMousePosOnOpeningCurrentPopup(&result);
		return result;
	}

	public unsafe static ImGuiPlatformIOPtr GetPlatformIO()
	{
		return new ImGuiPlatformIOPtr(ImGuiNative.igGetPlatformIO());
	}

	public static float GetScrollMaxX()
	{
		return ImGuiNative.igGetScrollMaxX();
	}

	public static float GetScrollMaxY()
	{
		return ImGuiNative.igGetScrollMaxY();
	}

	public static float GetScrollX()
	{
		return ImGuiNative.igGetScrollX();
	}

	public static float GetScrollY()
	{
		return ImGuiNative.igGetScrollY();
	}

	public unsafe static ImGuiStoragePtr GetStateStorage()
	{
		return new ImGuiStoragePtr(ImGuiNative.igGetStateStorage());
	}

	public unsafe static ImGuiStylePtr GetStyle()
	{
		return new ImGuiStylePtr(ImGuiNative.igGetStyle());
	}

	public unsafe static string GetStyleColorName(ImGuiCol idx)
	{
		return Util.StringFromPtr(ImGuiNative.igGetStyleColorName(idx));
	}

	public unsafe static Vector4* GetStyleColorVec4(ImGuiCol idx)
	{
		return ImGuiNative.igGetStyleColorVec4(idx);
	}

	public static float GetTextLineHeight()
	{
		return ImGuiNative.igGetTextLineHeight();
	}

	public static float GetTextLineHeightWithSpacing()
	{
		return ImGuiNative.igGetTextLineHeightWithSpacing();
	}

	public static double GetTime()
	{
		return ImGuiNative.igGetTime();
	}

	public static float GetTreeNodeToLabelSpacing()
	{
		return ImGuiNative.igGetTreeNodeToLabelSpacing();
	}

	public unsafe static string GetVersion()
	{
		return Util.StringFromPtr(ImGuiNative.igGetVersion());
	}

	public unsafe static Vector2 GetWindowContentRegionMax()
	{
		Vector2 result = default(Vector2);
		ImGuiNative.igGetWindowContentRegionMax(&result);
		return result;
	}

	public unsafe static Vector2 GetWindowContentRegionMin()
	{
		Vector2 result = default(Vector2);
		ImGuiNative.igGetWindowContentRegionMin(&result);
		return result;
	}

	public static uint GetWindowDockID()
	{
		return ImGuiNative.igGetWindowDockID();
	}

	public static float GetWindowDpiScale()
	{
		return ImGuiNative.igGetWindowDpiScale();
	}

	public unsafe static ImDrawListPtr GetWindowDrawList()
	{
		return new ImDrawListPtr(ImGuiNative.igGetWindowDrawList());
	}

	public static float GetWindowHeight()
	{
		return ImGuiNative.igGetWindowHeight();
	}

	public unsafe static Vector2 GetWindowPos()
	{
		Vector2 result = default(Vector2);
		ImGuiNative.igGetWindowPos(&result);
		return result;
	}

	public unsafe static Vector2 GetWindowSize()
	{
		Vector2 result = default(Vector2);
		ImGuiNative.igGetWindowSize(&result);
		return result;
	}

	public unsafe static ImGuiViewportPtr GetWindowViewport()
	{
		return new ImGuiViewportPtr(ImGuiNative.igGetWindowViewport());
	}

	public static float GetWindowWidth()
	{
		return ImGuiNative.igGetWindowWidth();
	}

	public static void Image(IntPtr user_texture_id, Vector2 size)
	{
		Vector2 uv = default(Vector2);
		Vector2 uv2 = new Vector2(1f, 1f);
		Vector4 tint_col = new Vector4(1f, 1f, 1f, 1f);
		ImGuiNative.igImage(user_texture_id, size, uv, uv2, tint_col, default(Vector4));
	}

	public static void Image(IntPtr user_texture_id, Vector2 size, Vector2 uv0)
	{
		Vector2 uv = new Vector2(1f, 1f);
		Vector4 tint_col = new Vector4(1f, 1f, 1f, 1f);
		ImGuiNative.igImage(user_texture_id, size, uv0, uv, tint_col, default(Vector4));
	}

	public static void Image(IntPtr user_texture_id, Vector2 size, Vector2 uv0, Vector2 uv1)
	{
		Vector4 tint_col = new Vector4(1f, 1f, 1f, 1f);
		ImGuiNative.igImage(user_texture_id, size, uv0, uv1, tint_col, default(Vector4));
	}

	public static void Image(IntPtr user_texture_id, Vector2 size, Vector2 uv0, Vector2 uv1, Vector4 tint_col)
	{
		ImGuiNative.igImage(user_texture_id, size, uv0, uv1, tint_col, default(Vector4));
	}

	public static void Image(IntPtr user_texture_id, Vector2 size, Vector2 uv0, Vector2 uv1, Vector4 tint_col, Vector4 border_col)
	{
		ImGuiNative.igImage(user_texture_id, size, uv0, uv1, tint_col, border_col);
	}

	public unsafe static bool ImageButton(string str_id, IntPtr user_texture_id, Vector2 size)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		Vector2 uv = default(Vector2);
		Vector2 uv2 = new Vector2(1f, 1f);
		Vector4 bg_col = default(Vector4);
		Vector4 tint_col = new Vector4(1f, 1f, 1f, 1f);
		byte num2 = ImGuiNative.igImageButton(ptr, user_texture_id, size, uv, uv2, bg_col, tint_col);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool ImageButton(string str_id, IntPtr user_texture_id, Vector2 size, Vector2 uv0)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		Vector2 uv = new Vector2(1f, 1f);
		Vector4 bg_col = default(Vector4);
		Vector4 tint_col = new Vector4(1f, 1f, 1f, 1f);
		byte num2 = ImGuiNative.igImageButton(ptr, user_texture_id, size, uv0, uv, bg_col, tint_col);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool ImageButton(string str_id, IntPtr user_texture_id, Vector2 size, Vector2 uv0, Vector2 uv1)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		Vector4 bg_col = default(Vector4);
		Vector4 tint_col = new Vector4(1f, 1f, 1f, 1f);
		byte num2 = ImGuiNative.igImageButton(ptr, user_texture_id, size, uv0, uv1, bg_col, tint_col);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool ImageButton(string str_id, IntPtr user_texture_id, Vector2 size, Vector2 uv0, Vector2 uv1, Vector4 bg_col)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		Vector4 tint_col = new Vector4(1f, 1f, 1f, 1f);
		byte num2 = ImGuiNative.igImageButton(ptr, user_texture_id, size, uv0, uv1, bg_col, tint_col);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool ImageButton(string str_id, IntPtr user_texture_id, Vector2 size, Vector2 uv0, Vector2 uv1, Vector4 bg_col, Vector4 tint_col)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igImageButton(ptr, user_texture_id, size, uv0, uv1, bg_col, tint_col);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public static void Indent()
	{
		ImGuiNative.igIndent(0f);
	}

	public static void Indent(float indent_w)
	{
		ImGuiNative.igIndent(indent_w);
	}

	public unsafe static bool InputDouble(string label, ref double v)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		double step = 0.0;
		double step_fast = 0.0;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.6f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.6f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		fixed (double* v2 = &v)
		{
			byte num3 = ImGuiNative.igInputDouble(ptr, v2, step, step_fast, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool InputDouble(string label, ref double v, double step)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		double step_fast = 0.0;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.6f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.6f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		fixed (double* v2 = &v)
		{
			byte num3 = ImGuiNative.igInputDouble(ptr, v2, step, step_fast, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool InputDouble(string label, ref double v, double step, double step_fast)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.6f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.6f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		fixed (double* v2 = &v)
		{
			byte num3 = ImGuiNative.igInputDouble(ptr, v2, step, step_fast, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool InputDouble(string label, ref double v, double step, double step_fast, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		fixed (double* v2 = &v)
		{
			byte num3 = ImGuiNative.igInputDouble(ptr, v2, step, step_fast, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool InputDouble(string label, ref double v, double step, double step_fast, string format, ImGuiInputTextFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (double* v2 = &v)
		{
			byte num3 = ImGuiNative.igInputDouble(ptr, v2, step, step_fast, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool InputFloat(string label, ref float v)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float step = 0f;
		float step_fast = 0f;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		fixed (float* v2 = &v)
		{
			byte num3 = ImGuiNative.igInputFloat(ptr, v2, step, step_fast, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool InputFloat(string label, ref float v, float step)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float step_fast = 0f;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		fixed (float* v2 = &v)
		{
			byte num3 = ImGuiNative.igInputFloat(ptr, v2, step, step_fast, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool InputFloat(string label, ref float v, float step, float step_fast)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		fixed (float* v2 = &v)
		{
			byte num3 = ImGuiNative.igInputFloat(ptr, v2, step, step_fast, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool InputFloat(string label, ref float v, float step, float step_fast, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		fixed (float* v2 = &v)
		{
			byte num3 = ImGuiNative.igInputFloat(ptr, v2, step, step_fast, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool InputFloat(string label, ref float v, float step, float step_fast, string format, ImGuiInputTextFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (float* v2 = &v)
		{
			byte num3 = ImGuiNative.igInputFloat(ptr, v2, step, step_fast, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool InputFloat2(string label, ref Vector2 v)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		fixed (Vector2* v2 = &v)
		{
			byte num3 = ImGuiNative.igInputFloat2(ptr, v2, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool InputFloat2(string label, ref Vector2 v, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		fixed (Vector2* v2 = &v)
		{
			byte num3 = ImGuiNative.igInputFloat2(ptr, v2, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool InputFloat2(string label, ref Vector2 v, string format, ImGuiInputTextFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (Vector2* v2 = &v)
		{
			byte num3 = ImGuiNative.igInputFloat2(ptr, v2, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool InputFloat3(string label, ref Vector3 v)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		fixed (Vector3* v2 = &v)
		{
			byte num3 = ImGuiNative.igInputFloat3(ptr, v2, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool InputFloat3(string label, ref Vector3 v, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		fixed (Vector3* v2 = &v)
		{
			byte num3 = ImGuiNative.igInputFloat3(ptr, v2, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool InputFloat3(string label, ref Vector3 v, string format, ImGuiInputTextFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (Vector3* v2 = &v)
		{
			byte num3 = ImGuiNative.igInputFloat3(ptr, v2, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool InputFloat4(string label, ref Vector4 v)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		fixed (Vector4* v2 = &v)
		{
			byte num3 = ImGuiNative.igInputFloat4(ptr, v2, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool InputFloat4(string label, ref Vector4 v, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		fixed (Vector4* v2 = &v)
		{
			byte num3 = ImGuiNative.igInputFloat4(ptr, v2, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool InputFloat4(string label, ref Vector4 v, string format, ImGuiInputTextFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (Vector4* v2 = &v)
		{
			byte num3 = ImGuiNative.igInputFloat4(ptr, v2, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool InputInt(string label, ref int v)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int step = 1;
		int step_fast = 100;
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		fixed (int* v2 = &v)
		{
			byte num2 = ImGuiNative.igInputInt(ptr, v2, step, step_fast, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return num2 != 0;
		}
	}

	public unsafe static bool InputInt(string label, ref int v, int step)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int step_fast = 100;
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		fixed (int* v2 = &v)
		{
			byte num2 = ImGuiNative.igInputInt(ptr, v2, step, step_fast, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return num2 != 0;
		}
	}

	public unsafe static bool InputInt(string label, ref int v, int step, int step_fast)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		fixed (int* v2 = &v)
		{
			byte num2 = ImGuiNative.igInputInt(ptr, v2, step, step_fast, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return num2 != 0;
		}
	}

	public unsafe static bool InputInt(string label, ref int v, int step, int step_fast, ImGuiInputTextFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		fixed (int* v2 = &v)
		{
			byte num2 = ImGuiNative.igInputInt(ptr, v2, step, step_fast, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return num2 != 0;
		}
	}

	public unsafe static bool InputInt2(string label, ref int v)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		fixed (int* v2 = &v)
		{
			byte num2 = ImGuiNative.igInputInt2(ptr, v2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return num2 != 0;
		}
	}

	public unsafe static bool InputInt2(string label, ref int v, ImGuiInputTextFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		fixed (int* v2 = &v)
		{
			byte num2 = ImGuiNative.igInputInt2(ptr, v2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return num2 != 0;
		}
	}

	public unsafe static bool InputInt3(string label, ref int v)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		fixed (int* v2 = &v)
		{
			byte num2 = ImGuiNative.igInputInt3(ptr, v2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return num2 != 0;
		}
	}

	public unsafe static bool InputInt3(string label, ref int v, ImGuiInputTextFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		fixed (int* v2 = &v)
		{
			byte num2 = ImGuiNative.igInputInt3(ptr, v2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return num2 != 0;
		}
	}

	public unsafe static bool InputInt4(string label, ref int v)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		fixed (int* v2 = &v)
		{
			byte num2 = ImGuiNative.igInputInt4(ptr, v2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return num2 != 0;
		}
	}

	public unsafe static bool InputInt4(string label, ref int v, ImGuiInputTextFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		fixed (int* v2 = &v)
		{
			byte num2 = ImGuiNative.igInputInt4(ptr, v2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return num2 != 0;
		}
	}

	public unsafe static bool InputScalar(string label, ImGuiDataType data_type, IntPtr p_data)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_step = null;
		void* p_step_fast = null;
		byte* format = null;
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		byte num2 = ImGuiNative.igInputScalar(ptr, data_type, p_data2, p_step, p_step_fast, format, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool InputScalar(string label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_step)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_step2 = p_step.ToPointer();
		void* p_step_fast = null;
		byte* format = null;
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		byte num2 = ImGuiNative.igInputScalar(ptr, data_type, p_data2, p_step2, p_step_fast, format, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool InputScalar(string label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_step, IntPtr p_step_fast)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_step2 = p_step.ToPointer();
		void* p_step_fast2 = p_step_fast.ToPointer();
		byte* format = null;
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		byte num2 = ImGuiNative.igInputScalar(ptr, data_type, p_data2, p_step2, p_step_fast2, format, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool InputScalar(string label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_step, IntPtr p_step_fast, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_step2 = p_step.ToPointer();
		void* p_step_fast2 = p_step_fast.ToPointer();
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		byte num3 = ImGuiNative.igInputScalar(ptr, data_type, p_data2, p_step2, p_step_fast2, ptr2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
		return num3 != 0;
	}

	public unsafe static bool InputScalar(string label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_step, IntPtr p_step_fast, string format, ImGuiInputTextFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_step2 = p_step.ToPointer();
		void* p_step_fast2 = p_step_fast.ToPointer();
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		byte num3 = ImGuiNative.igInputScalar(ptr, data_type, p_data2, p_step2, p_step_fast2, ptr2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
		return num3 != 0;
	}

	public unsafe static bool InputScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_step = null;
		void* p_step_fast = null;
		byte* format = null;
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		byte num2 = ImGuiNative.igInputScalarN(ptr, data_type, p_data2, components, p_step, p_step_fast, format, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool InputScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components, IntPtr p_step)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_step2 = p_step.ToPointer();
		void* p_step_fast = null;
		byte* format = null;
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		byte num2 = ImGuiNative.igInputScalarN(ptr, data_type, p_data2, components, p_step2, p_step_fast, format, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool InputScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components, IntPtr p_step, IntPtr p_step_fast)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_step2 = p_step.ToPointer();
		void* p_step_fast2 = p_step_fast.ToPointer();
		byte* format = null;
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		byte num2 = ImGuiNative.igInputScalarN(ptr, data_type, p_data2, components, p_step2, p_step_fast2, format, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool InputScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components, IntPtr p_step, IntPtr p_step_fast, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_step2 = p_step.ToPointer();
		void* p_step_fast2 = p_step_fast.ToPointer();
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
		byte num3 = ImGuiNative.igInputScalarN(ptr, data_type, p_data2, components, p_step2, p_step_fast2, ptr2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
		return num3 != 0;
	}

	public unsafe static bool InputScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components, IntPtr p_step, IntPtr p_step_fast, string format, ImGuiInputTextFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_step2 = p_step.ToPointer();
		void* p_step_fast2 = p_step_fast.ToPointer();
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		byte num3 = ImGuiNative.igInputScalarN(ptr, data_type, p_data2, components, p_step2, p_step_fast2, ptr2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
		return num3 != 0;
	}

	public unsafe static bool InvisibleButton(string str_id, Vector2 size)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiButtonFlags flags = ImGuiButtonFlags.None;
		byte num2 = ImGuiNative.igInvisibleButton(ptr, size, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool InvisibleButton(string str_id, Vector2 size, ImGuiButtonFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igInvisibleButton(ptr, size, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public static bool IsAnyItemActive()
	{
		return ImGuiNative.igIsAnyItemActive() != 0;
	}

	public static bool IsAnyItemFocused()
	{
		return ImGuiNative.igIsAnyItemFocused() != 0;
	}

	public static bool IsAnyItemHovered()
	{
		return ImGuiNative.igIsAnyItemHovered() != 0;
	}

	public static bool IsAnyMouseDown()
	{
		return ImGuiNative.igIsAnyMouseDown() != 0;
	}

	public static bool IsItemActivated()
	{
		return ImGuiNative.igIsItemActivated() != 0;
	}

	public static bool IsItemActive()
	{
		return ImGuiNative.igIsItemActive() != 0;
	}

	public static bool IsItemClicked()
	{
		return ImGuiNative.igIsItemClicked(ImGuiMouseButton.Left) != 0;
	}

	public static bool IsItemClicked(ImGuiMouseButton mouse_button)
	{
		return ImGuiNative.igIsItemClicked(mouse_button) != 0;
	}

	public static bool IsItemDeactivated()
	{
		return ImGuiNative.igIsItemDeactivated() != 0;
	}

	public static bool IsItemDeactivatedAfterEdit()
	{
		return ImGuiNative.igIsItemDeactivatedAfterEdit() != 0;
	}

	public static bool IsItemEdited()
	{
		return ImGuiNative.igIsItemEdited() != 0;
	}

	public static bool IsItemFocused()
	{
		return ImGuiNative.igIsItemFocused() != 0;
	}

	public static bool IsItemHovered()
	{
		return ImGuiNative.igIsItemHovered(ImGuiHoveredFlags.None) != 0;
	}

	public static bool IsItemHovered(ImGuiHoveredFlags flags)
	{
		return ImGuiNative.igIsItemHovered(flags) != 0;
	}

	public static bool IsItemToggledOpen()
	{
		return ImGuiNative.igIsItemToggledOpen() != 0;
	}

	public static bool IsItemVisible()
	{
		return ImGuiNative.igIsItemVisible() != 0;
	}

	public static bool IsKeyDown(ImGuiKey key)
	{
		return ImGuiNative.igIsKeyDown_Nil(key) != 0;
	}

	public static bool IsKeyPressed(ImGuiKey key)
	{
		byte repeat = 1;
		return ImGuiNative.igIsKeyPressed_Bool(key, repeat) != 0;
	}

	public static bool IsKeyPressed(ImGuiKey key, bool repeat)
	{
		byte repeat2 = (byte)(repeat ? 1 : 0);
		return ImGuiNative.igIsKeyPressed_Bool(key, repeat2) != 0;
	}

	public static bool IsKeyReleased(ImGuiKey key)
	{
		return ImGuiNative.igIsKeyReleased_Nil(key) != 0;
	}

	public static bool IsMouseClicked(ImGuiMouseButton button)
	{
		byte repeat = 0;
		return ImGuiNative.igIsMouseClicked_Bool(button, repeat) != 0;
	}

	public static bool IsMouseClicked(ImGuiMouseButton button, bool repeat)
	{
		byte repeat2 = (byte)(repeat ? 1 : 0);
		return ImGuiNative.igIsMouseClicked_Bool(button, repeat2) != 0;
	}

	public static bool IsMouseDoubleClicked(ImGuiMouseButton button)
	{
		return ImGuiNative.igIsMouseDoubleClicked(button) != 0;
	}

	public static bool IsMouseDown(ImGuiMouseButton button)
	{
		return ImGuiNative.igIsMouseDown_Nil(button) != 0;
	}

	public static bool IsMouseDragging(ImGuiMouseButton button)
	{
		float lock_threshold = -1f;
		return ImGuiNative.igIsMouseDragging(button, lock_threshold) != 0;
	}

	public static bool IsMouseDragging(ImGuiMouseButton button, float lock_threshold)
	{
		return ImGuiNative.igIsMouseDragging(button, lock_threshold) != 0;
	}

	public static bool IsMouseHoveringRect(Vector2 r_min, Vector2 r_max)
	{
		byte clip = 1;
		return ImGuiNative.igIsMouseHoveringRect(r_min, r_max, clip) != 0;
	}

	public static bool IsMouseHoveringRect(Vector2 r_min, Vector2 r_max, bool clip)
	{
		byte clip2 = (byte)(clip ? 1 : 0);
		return ImGuiNative.igIsMouseHoveringRect(r_min, r_max, clip2) != 0;
	}

	public unsafe static bool IsMousePosValid()
	{
		Vector2* mouse_pos = null;
		return ImGuiNative.igIsMousePosValid(mouse_pos) != 0;
	}

	public unsafe static bool IsMousePosValid(ref Vector2 mouse_pos)
	{
		fixed (Vector2* mouse_pos2 = &mouse_pos)
		{
			return ImGuiNative.igIsMousePosValid(mouse_pos2) != 0;
		}
	}

	public static bool IsMouseReleased(ImGuiMouseButton button)
	{
		return ImGuiNative.igIsMouseReleased_Nil(button) != 0;
	}

	public unsafe static bool IsPopupOpen(string str_id)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiPopupFlags flags = ImGuiPopupFlags.None;
		byte num2 = ImGuiNative.igIsPopupOpen_Str(ptr, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool IsPopupOpen(string str_id, ImGuiPopupFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igIsPopupOpen_Str(ptr, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public static bool IsRectVisible(Vector2 size)
	{
		return ImGuiNative.igIsRectVisible_Nil(size) != 0;
	}

	public static bool IsRectVisible(Vector2 rect_min, Vector2 rect_max)
	{
		return ImGuiNative.igIsRectVisible_Vec2(rect_min, rect_max) != 0;
	}

	public static bool IsWindowAppearing()
	{
		return ImGuiNative.igIsWindowAppearing() != 0;
	}

	public static bool IsWindowCollapsed()
	{
		return ImGuiNative.igIsWindowCollapsed() != 0;
	}

	public static bool IsWindowDocked()
	{
		return ImGuiNative.igIsWindowDocked() != 0;
	}

	public static bool IsWindowFocused()
	{
		return ImGuiNative.igIsWindowFocused(ImGuiFocusedFlags.None) != 0;
	}

	public static bool IsWindowFocused(ImGuiFocusedFlags flags)
	{
		return ImGuiNative.igIsWindowFocused(flags) != 0;
	}

	public static bool IsWindowHovered()
	{
		return ImGuiNative.igIsWindowHovered(ImGuiHoveredFlags.None) != 0;
	}

	public static bool IsWindowHovered(ImGuiHoveredFlags flags)
	{
		return ImGuiNative.igIsWindowHovered(flags) != 0;
	}

	public unsafe static void LabelText(string label, string fmt)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (fmt != null)
		{
			num2 = Encoding.UTF8.GetByteCount(fmt);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(fmt, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiNative.igLabelText(ptr, ptr2);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
	}

	public unsafe static bool ListBox(string label, ref int current_item, string[] items, int items_count)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int* ptr2 = stackalloc int[items.Length];
		int num2 = 0;
		for (int i = 0; i < items.Length; i++)
		{
			string s = items[i];
			ptr2[i] = Encoding.UTF8.GetByteCount(s);
			num2 += ptr2[i] + 1;
		}
		byte* ptr3 = stackalloc byte[(int)(uint)num2];
		int num3 = 0;
		for (int j = 0; j < items.Length; j++)
		{
			string text = items[j];
			fixed (char* chars = text)
			{
				num3 += Encoding.UTF8.GetBytes(chars, text.Length, ptr3 + num3, ptr2[j]);
				ptr3[num3] = 0;
				num3++;
			}
		}
		byte** ptr4 = stackalloc byte*[items.Length];
		num3 = 0;
		for (int k = 0; k < items.Length; k++)
		{
			ptr4[k] = ptr3 + num3;
			num3 += ptr2[k] + 1;
		}
		int height_in_items = -1;
		fixed (int* current_item2 = &current_item)
		{
			byte num4 = ImGuiNative.igListBox_Str_arr(ptr, current_item2, ptr4, items_count, height_in_items);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return num4 != 0;
		}
	}

	public unsafe static bool ListBox(string label, ref int current_item, string[] items, int items_count, int height_in_items)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int* ptr2 = stackalloc int[items.Length];
		int num2 = 0;
		for (int i = 0; i < items.Length; i++)
		{
			string s = items[i];
			ptr2[i] = Encoding.UTF8.GetByteCount(s);
			num2 += ptr2[i] + 1;
		}
		byte* ptr3 = stackalloc byte[(int)(uint)num2];
		int num3 = 0;
		for (int j = 0; j < items.Length; j++)
		{
			string text = items[j];
			fixed (char* chars = text)
			{
				num3 += Encoding.UTF8.GetBytes(chars, text.Length, ptr3 + num3, ptr2[j]);
				ptr3[num3] = 0;
				num3++;
			}
		}
		byte** ptr4 = stackalloc byte*[items.Length];
		num3 = 0;
		for (int k = 0; k < items.Length; k++)
		{
			ptr4[k] = ptr3 + num3;
			num3 += ptr2[k] + 1;
		}
		fixed (int* current_item2 = &current_item)
		{
			byte num4 = ImGuiNative.igListBox_Str_arr(ptr, current_item2, ptr4, items_count, height_in_items);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return num4 != 0;
		}
	}

	public unsafe static void LoadIniSettingsFromDisk(string ini_filename)
	{
		int num = 0;
		byte* ptr;
		if (ini_filename != null)
		{
			num = Encoding.UTF8.GetByteCount(ini_filename);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(ini_filename, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igLoadIniSettingsFromDisk(ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static void LoadIniSettingsFromMemory(string ini_data)
	{
		int num = 0;
		byte* ptr;
		if (ini_data != null)
		{
			num = Encoding.UTF8.GetByteCount(ini_data);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(ini_data, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		uint ini_size = 0u;
		ImGuiNative.igLoadIniSettingsFromMemory(ptr, ini_size);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static void LoadIniSettingsFromMemory(string ini_data, uint ini_size)
	{
		int num = 0;
		byte* ptr;
		if (ini_data != null)
		{
			num = Encoding.UTF8.GetByteCount(ini_data);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(ini_data, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igLoadIniSettingsFromMemory(ptr, ini_size);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public static void LogButtons()
	{
		ImGuiNative.igLogButtons();
	}

	public static void LogFinish()
	{
		ImGuiNative.igLogFinish();
	}

	public unsafe static void LogText(string fmt)
	{
		int num = 0;
		byte* ptr;
		if (fmt != null)
		{
			num = Encoding.UTF8.GetByteCount(fmt);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(fmt, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igLogText(ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public static void LogToClipboard()
	{
		ImGuiNative.igLogToClipboard(-1);
	}

	public static void LogToClipboard(int auto_open_depth)
	{
		ImGuiNative.igLogToClipboard(auto_open_depth);
	}

	public unsafe static void LogToFile()
	{
		byte* filename = null;
		ImGuiNative.igLogToFile(-1, filename);
	}

	public unsafe static void LogToFile(int auto_open_depth)
	{
		byte* filename = null;
		ImGuiNative.igLogToFile(auto_open_depth, filename);
	}

	public unsafe static void LogToFile(int auto_open_depth, string filename)
	{
		int num = 0;
		byte* ptr;
		if (filename != null)
		{
			num = Encoding.UTF8.GetByteCount(filename);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(filename, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igLogToFile(auto_open_depth, ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public static void LogToTTY()
	{
		ImGuiNative.igLogToTTY(-1);
	}

	public static void LogToTTY(int auto_open_depth)
	{
		ImGuiNative.igLogToTTY(auto_open_depth);
	}

	public unsafe static IntPtr MemAlloc(uint size)
	{
		return (IntPtr)ImGuiNative.igMemAlloc(size);
	}

	public unsafe static void MemFree(IntPtr ptr)
	{
		ImGuiNative.igMemFree(ptr.ToPointer());
	}

	public unsafe static bool MenuItem(string label)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte* shortcut = null;
		byte selected = 0;
		byte enabled = 1;
		byte num2 = ImGuiNative.igMenuItem_Bool(ptr, shortcut, selected, enabled);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool MenuItem(string label, string shortcut)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (shortcut != null)
		{
			num2 = Encoding.UTF8.GetByteCount(shortcut);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(shortcut, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		byte selected = 0;
		byte enabled = 1;
		byte num3 = ImGuiNative.igMenuItem_Bool(ptr, ptr2, selected, enabled);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
		return num3 != 0;
	}

	public unsafe static bool MenuItem(string label, string shortcut, bool selected)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (shortcut != null)
		{
			num2 = Encoding.UTF8.GetByteCount(shortcut);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(shortcut, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		byte selected2 = (byte)(selected ? 1 : 0);
		byte enabled = 1;
		byte num3 = ImGuiNative.igMenuItem_Bool(ptr, ptr2, selected2, enabled);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
		return num3 != 0;
	}

	public unsafe static bool MenuItem(string label, string shortcut, bool selected, bool enabled)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (shortcut != null)
		{
			num2 = Encoding.UTF8.GetByteCount(shortcut);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(shortcut, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		byte selected2 = (byte)(selected ? 1 : 0);
		byte enabled2 = (byte)(enabled ? 1 : 0);
		byte num3 = ImGuiNative.igMenuItem_Bool(ptr, ptr2, selected2, enabled2);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
		return num3 != 0;
	}

	public unsafe static bool MenuItem(string label, string shortcut, ref bool p_selected)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (shortcut != null)
		{
			num2 = Encoding.UTF8.GetByteCount(shortcut);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(shortcut, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		byte b = (byte)(p_selected ? 1 : 0);
		byte* p_selected2 = &b;
		byte enabled = 1;
		byte num3 = ImGuiNative.igMenuItem_BoolPtr(ptr, ptr2, p_selected2, enabled);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
		p_selected = b != 0;
		return num3 != 0;
	}

	public unsafe static bool MenuItem(string label, string shortcut, ref bool p_selected, bool enabled)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (shortcut != null)
		{
			num2 = Encoding.UTF8.GetByteCount(shortcut);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(shortcut, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		byte b = (byte)(p_selected ? 1 : 0);
		byte* p_selected2 = &b;
		byte enabled2 = (byte)(enabled ? 1 : 0);
		byte num3 = ImGuiNative.igMenuItem_BoolPtr(ptr, ptr2, p_selected2, enabled2);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
		p_selected = b != 0;
		return num3 != 0;
	}

	public static void NewFrame()
	{
		ImGuiNative.igNewFrame();
	}

	public static void NewLine()
	{
		ImGuiNative.igNewLine();
	}

	public static void NextColumn()
	{
		ImGuiNative.igNextColumn();
	}

	public unsafe static void OpenPopup(string str_id)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiPopupFlags popup_flags = ImGuiPopupFlags.None;
		ImGuiNative.igOpenPopup_Str(ptr, popup_flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static void OpenPopup(string str_id, ImGuiPopupFlags popup_flags)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igOpenPopup_Str(ptr, popup_flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public static void OpenPopup(uint id)
	{
		ImGuiPopupFlags popup_flags = ImGuiPopupFlags.None;
		ImGuiNative.igOpenPopup_ID(id, popup_flags);
	}

	public static void OpenPopup(uint id, ImGuiPopupFlags popup_flags)
	{
		ImGuiNative.igOpenPopup_ID(id, popup_flags);
	}

	public unsafe static void OpenPopupOnItemClick()
	{
		byte* str_id = null;
		ImGuiPopupFlags popup_flags = ImGuiPopupFlags.MouseButtonRight;
		ImGuiNative.igOpenPopupOnItemClick(str_id, popup_flags);
	}

	public unsafe static void OpenPopupOnItemClick(string str_id)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiPopupFlags popup_flags = ImGuiPopupFlags.MouseButtonRight;
		ImGuiNative.igOpenPopupOnItemClick(ptr, popup_flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static void OpenPopupOnItemClick(string str_id, ImGuiPopupFlags popup_flags)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igOpenPopupOnItemClick(ptr, popup_flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static void PlotHistogram(string label, ref float values, int values_count)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int values_offset = 0;
		byte* overlay_text = null;
		float scale_min = float.MaxValue;
		float scale_max = float.MaxValue;
		Vector2 graph_size = default(Vector2);
		int stride = 4;
		fixed (float* values2 = &values)
		{
			ImGuiNative.igPlotHistogram_FloatPtr(ptr, values2, values_count, values_offset, overlay_text, scale_min, scale_max, graph_size, stride);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}
	}

	public unsafe static void PlotHistogram(string label, ref float values, int values_count, int values_offset)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte* overlay_text = null;
		float scale_min = float.MaxValue;
		float scale_max = float.MaxValue;
		Vector2 graph_size = default(Vector2);
		int stride = 4;
		fixed (float* values2 = &values)
		{
			ImGuiNative.igPlotHistogram_FloatPtr(ptr, values2, values_count, values_offset, overlay_text, scale_min, scale_max, graph_size, stride);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}
	}

	public unsafe static void PlotHistogram(string label, ref float values, int values_count, int values_offset, string overlay_text)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (overlay_text != null)
		{
			num2 = Encoding.UTF8.GetByteCount(overlay_text);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(overlay_text, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		float scale_min = float.MaxValue;
		float scale_max = float.MaxValue;
		Vector2 graph_size = default(Vector2);
		int stride = 4;
		fixed (float* values2 = &values)
		{
			ImGuiNative.igPlotHistogram_FloatPtr(ptr, values2, values_count, values_offset, ptr2, scale_min, scale_max, graph_size, stride);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
		}
	}

	public unsafe static void PlotHistogram(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (overlay_text != null)
		{
			num2 = Encoding.UTF8.GetByteCount(overlay_text);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(overlay_text, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		float scale_max = float.MaxValue;
		Vector2 graph_size = default(Vector2);
		int stride = 4;
		fixed (float* values2 = &values)
		{
			ImGuiNative.igPlotHistogram_FloatPtr(ptr, values2, values_count, values_offset, ptr2, scale_min, scale_max, graph_size, stride);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
		}
	}

	public unsafe static void PlotHistogram(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min, float scale_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (overlay_text != null)
		{
			num2 = Encoding.UTF8.GetByteCount(overlay_text);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(overlay_text, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		Vector2 graph_size = default(Vector2);
		int stride = 4;
		fixed (float* values2 = &values)
		{
			ImGuiNative.igPlotHistogram_FloatPtr(ptr, values2, values_count, values_offset, ptr2, scale_min, scale_max, graph_size, stride);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
		}
	}

	public unsafe static void PlotHistogram(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min, float scale_max, Vector2 graph_size)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (overlay_text != null)
		{
			num2 = Encoding.UTF8.GetByteCount(overlay_text);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(overlay_text, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		int stride = 4;
		fixed (float* values2 = &values)
		{
			ImGuiNative.igPlotHistogram_FloatPtr(ptr, values2, values_count, values_offset, ptr2, scale_min, scale_max, graph_size, stride);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
		}
	}

	public unsafe static void PlotHistogram(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min, float scale_max, Vector2 graph_size, int stride)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (overlay_text != null)
		{
			num2 = Encoding.UTF8.GetByteCount(overlay_text);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(overlay_text, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (float* values2 = &values)
		{
			ImGuiNative.igPlotHistogram_FloatPtr(ptr, values2, values_count, values_offset, ptr2, scale_min, scale_max, graph_size, stride);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
		}
	}

	public unsafe static void PlotLines(string label, ref float values, int values_count)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int values_offset = 0;
		byte* overlay_text = null;
		float scale_min = float.MaxValue;
		float scale_max = float.MaxValue;
		Vector2 graph_size = default(Vector2);
		int stride = 4;
		fixed (float* values2 = &values)
		{
			ImGuiNative.igPlotLines_FloatPtr(ptr, values2, values_count, values_offset, overlay_text, scale_min, scale_max, graph_size, stride);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}
	}

	public unsafe static void PlotLines(string label, ref float values, int values_count, int values_offset)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte* overlay_text = null;
		float scale_min = float.MaxValue;
		float scale_max = float.MaxValue;
		Vector2 graph_size = default(Vector2);
		int stride = 4;
		fixed (float* values2 = &values)
		{
			ImGuiNative.igPlotLines_FloatPtr(ptr, values2, values_count, values_offset, overlay_text, scale_min, scale_max, graph_size, stride);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}
	}

	public unsafe static void PlotLines(string label, ref float values, int values_count, int values_offset, string overlay_text)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (overlay_text != null)
		{
			num2 = Encoding.UTF8.GetByteCount(overlay_text);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(overlay_text, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		float scale_min = float.MaxValue;
		float scale_max = float.MaxValue;
		Vector2 graph_size = default(Vector2);
		int stride = 4;
		fixed (float* values2 = &values)
		{
			ImGuiNative.igPlotLines_FloatPtr(ptr, values2, values_count, values_offset, ptr2, scale_min, scale_max, graph_size, stride);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
		}
	}

	public unsafe static void PlotLines(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (overlay_text != null)
		{
			num2 = Encoding.UTF8.GetByteCount(overlay_text);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(overlay_text, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		float scale_max = float.MaxValue;
		Vector2 graph_size = default(Vector2);
		int stride = 4;
		fixed (float* values2 = &values)
		{
			ImGuiNative.igPlotLines_FloatPtr(ptr, values2, values_count, values_offset, ptr2, scale_min, scale_max, graph_size, stride);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
		}
	}

	public unsafe static void PlotLines(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min, float scale_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (overlay_text != null)
		{
			num2 = Encoding.UTF8.GetByteCount(overlay_text);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(overlay_text, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		Vector2 graph_size = default(Vector2);
		int stride = 4;
		fixed (float* values2 = &values)
		{
			ImGuiNative.igPlotLines_FloatPtr(ptr, values2, values_count, values_offset, ptr2, scale_min, scale_max, graph_size, stride);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
		}
	}

	public unsafe static void PlotLines(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min, float scale_max, Vector2 graph_size)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (overlay_text != null)
		{
			num2 = Encoding.UTF8.GetByteCount(overlay_text);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(overlay_text, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		int stride = 4;
		fixed (float* values2 = &values)
		{
			ImGuiNative.igPlotLines_FloatPtr(ptr, values2, values_count, values_offset, ptr2, scale_min, scale_max, graph_size, stride);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
		}
	}

	public unsafe static void PlotLines(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min, float scale_max, Vector2 graph_size, int stride)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (overlay_text != null)
		{
			num2 = Encoding.UTF8.GetByteCount(overlay_text);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(overlay_text, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (float* values2 = &values)
		{
			ImGuiNative.igPlotLines_FloatPtr(ptr, values2, values_count, values_offset, ptr2, scale_min, scale_max, graph_size, stride);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
		}
	}

	public static void PopAllowKeyboardFocus()
	{
		ImGuiNative.igPopAllowKeyboardFocus();
	}

	public static void PopButtonRepeat()
	{
		ImGuiNative.igPopButtonRepeat();
	}

	public static void PopClipRect()
	{
		ImGuiNative.igPopClipRect();
	}

	public static void PopFont()
	{
		ImGuiNative.igPopFont();
	}

	public static void PopID()
	{
		ImGuiNative.igPopID();
	}

	public static void PopItemWidth()
	{
		ImGuiNative.igPopItemWidth();
	}

	public static void PopStyleColor()
	{
		ImGuiNative.igPopStyleColor(1);
	}

	public static void PopStyleColor(int count)
	{
		ImGuiNative.igPopStyleColor(count);
	}

	public static void PopStyleVar()
	{
		ImGuiNative.igPopStyleVar(1);
	}

	public static void PopStyleVar(int count)
	{
		ImGuiNative.igPopStyleVar(count);
	}

	public static void PopTextWrapPos()
	{
		ImGuiNative.igPopTextWrapPos();
	}

	public unsafe static void ProgressBar(float fraction)
	{
		Vector2 size_arg = new Vector2(float.MaxValue, 0f);
		byte* overlay = null;
		ImGuiNative.igProgressBar(fraction, size_arg, overlay);
	}

	public unsafe static void ProgressBar(float fraction, Vector2 size_arg)
	{
		byte* overlay = null;
		ImGuiNative.igProgressBar(fraction, size_arg, overlay);
	}

	public unsafe static void ProgressBar(float fraction, Vector2 size_arg, string overlay)
	{
		int num = 0;
		byte* ptr;
		if (overlay != null)
		{
			num = Encoding.UTF8.GetByteCount(overlay);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(overlay, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igProgressBar(fraction, size_arg, ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public static void PushAllowKeyboardFocus(bool allow_keyboard_focus)
	{
		ImGuiNative.igPushAllowKeyboardFocus((byte)(allow_keyboard_focus ? 1 : 0));
	}

	public static void PushButtonRepeat(bool repeat)
	{
		ImGuiNative.igPushButtonRepeat((byte)(repeat ? 1 : 0));
	}

	public static void PushClipRect(Vector2 clip_rect_min, Vector2 clip_rect_max, bool intersect_with_current_clip_rect)
	{
		byte intersect_with_current_clip_rect2 = (byte)(intersect_with_current_clip_rect ? 1 : 0);
		ImGuiNative.igPushClipRect(clip_rect_min, clip_rect_max, intersect_with_current_clip_rect2);
	}

	public unsafe static void PushFont(ImFontPtr font)
	{
		ImGuiNative.igPushFont(font.NativePtr);
	}

	public unsafe static void PushID(string str_id)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igPushID_Str(ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static void PushID(IntPtr ptr_id)
	{
		ImGuiNative.igPushID_Ptr(ptr_id.ToPointer());
	}

	public static void PushID(int int_id)
	{
		ImGuiNative.igPushID_Int(int_id);
	}

	public static void PushItemWidth(float item_width)
	{
		ImGuiNative.igPushItemWidth(item_width);
	}

	public static void PushStyleColor(ImGuiCol idx, uint col)
	{
		ImGuiNative.igPushStyleColor_U32(idx, col);
	}

	public static void PushStyleColor(ImGuiCol idx, Vector4 col)
	{
		ImGuiNative.igPushStyleColor_Vec4(idx, col);
	}

	public static void PushStyleVar(ImGuiStyleVar idx, float val)
	{
		ImGuiNative.igPushStyleVar_Float(idx, val);
	}

	public static void PushStyleVar(ImGuiStyleVar idx, Vector2 val)
	{
		ImGuiNative.igPushStyleVar_Vec2(idx, val);
	}

	public static void PushTextWrapPos()
	{
		ImGuiNative.igPushTextWrapPos(0f);
	}

	public static void PushTextWrapPos(float wrap_local_pos_x)
	{
		ImGuiNative.igPushTextWrapPos(wrap_local_pos_x);
	}

	public unsafe static bool RadioButton(string label, bool active)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte active2 = (byte)(active ? 1 : 0);
		byte num2 = ImGuiNative.igRadioButton_Bool(ptr, active2);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool RadioButton(string label, ref int v, int v_button)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		fixed (int* v2 = &v)
		{
			byte num2 = ImGuiNative.igRadioButton_IntPtr(ptr, v2, v_button);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return num2 != 0;
		}
	}

	public static void Render()
	{
		ImGuiNative.igRender();
	}

	public unsafe static void RenderPlatformWindowsDefault()
	{
		void* platform_render_arg = null;
		void* renderer_render_arg = null;
		ImGuiNative.igRenderPlatformWindowsDefault(platform_render_arg, renderer_render_arg);
	}

	public unsafe static void RenderPlatformWindowsDefault(IntPtr platform_render_arg)
	{
		void* platform_render_arg2 = platform_render_arg.ToPointer();
		void* renderer_render_arg = null;
		ImGuiNative.igRenderPlatformWindowsDefault(platform_render_arg2, renderer_render_arg);
	}

	public unsafe static void RenderPlatformWindowsDefault(IntPtr platform_render_arg, IntPtr renderer_render_arg)
	{
		void* platform_render_arg2 = platform_render_arg.ToPointer();
		void* renderer_render_arg2 = renderer_render_arg.ToPointer();
		ImGuiNative.igRenderPlatformWindowsDefault(platform_render_arg2, renderer_render_arg2);
	}

	public static void ResetMouseDragDelta()
	{
		ImGuiNative.igResetMouseDragDelta(ImGuiMouseButton.Left);
	}

	public static void ResetMouseDragDelta(ImGuiMouseButton button)
	{
		ImGuiNative.igResetMouseDragDelta(button);
	}

	public static void SameLine()
	{
		float spacing = -1f;
		ImGuiNative.igSameLine(0f, spacing);
	}

	public static void SameLine(float offset_from_start_x)
	{
		float spacing = -1f;
		ImGuiNative.igSameLine(offset_from_start_x, spacing);
	}

	public static void SameLine(float offset_from_start_x, float spacing)
	{
		ImGuiNative.igSameLine(offset_from_start_x, spacing);
	}

	public unsafe static void SaveIniSettingsToDisk(string ini_filename)
	{
		int num = 0;
		byte* ptr;
		if (ini_filename != null)
		{
			num = Encoding.UTF8.GetByteCount(ini_filename);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(ini_filename, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igSaveIniSettingsToDisk(ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static string SaveIniSettingsToMemory()
	{
		uint* out_ini_size = null;
		return Util.StringFromPtr(ImGuiNative.igSaveIniSettingsToMemory(out_ini_size));
	}

	public unsafe static string SaveIniSettingsToMemory(out uint out_ini_size)
	{
		fixed (uint* out_ini_size2 = &out_ini_size)
		{
			return Util.StringFromPtr(ImGuiNative.igSaveIniSettingsToMemory(out_ini_size2));
		}
	}

	public unsafe static bool Selectable(string label)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte selected = 0;
		ImGuiSelectableFlags flags = ImGuiSelectableFlags.None;
		byte num2 = ImGuiNative.igSelectable_Bool(ptr, selected, flags, default(Vector2));
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool Selectable(string label, bool selected)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte selected2 = (byte)(selected ? 1 : 0);
		ImGuiSelectableFlags flags = ImGuiSelectableFlags.None;
		byte num2 = ImGuiNative.igSelectable_Bool(ptr, selected2, flags, default(Vector2));
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool Selectable(string label, bool selected, ImGuiSelectableFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte selected2 = (byte)(selected ? 1 : 0);
		byte num2 = ImGuiNative.igSelectable_Bool(ptr, selected2, flags, default(Vector2));
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool Selectable(string label, bool selected, ImGuiSelectableFlags flags, Vector2 size)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte selected2 = (byte)(selected ? 1 : 0);
		byte num2 = ImGuiNative.igSelectable_Bool(ptr, selected2, flags, size);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool Selectable(string label, ref bool p_selected)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte b = (byte)(p_selected ? 1 : 0);
		byte* p_selected2 = &b;
		ImGuiSelectableFlags flags = ImGuiSelectableFlags.None;
		byte num2 = ImGuiNative.igSelectable_BoolPtr(ptr, p_selected2, flags, default(Vector2));
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		p_selected = b != 0;
		return num2 != 0;
	}

	public unsafe static bool Selectable(string label, ref bool p_selected, ImGuiSelectableFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte b = (byte)(p_selected ? 1 : 0);
		byte* p_selected2 = &b;
		byte num2 = ImGuiNative.igSelectable_BoolPtr(ptr, p_selected2, flags, default(Vector2));
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		p_selected = b != 0;
		return num2 != 0;
	}

	public unsafe static bool Selectable(string label, ref bool p_selected, ImGuiSelectableFlags flags, Vector2 size)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte b = (byte)(p_selected ? 1 : 0);
		byte* p_selected2 = &b;
		byte num2 = ImGuiNative.igSelectable_BoolPtr(ptr, p_selected2, flags, size);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		p_selected = b != 0;
		return num2 != 0;
	}

	public static void Separator()
	{
		ImGuiNative.igSeparator();
	}

	public unsafe static void SetAllocatorFunctions(IntPtr alloc_func, IntPtr free_func)
	{
		void* user_data = null;
		ImGuiNative.igSetAllocatorFunctions(alloc_func, free_func, user_data);
	}

	public unsafe static void SetAllocatorFunctions(IntPtr alloc_func, IntPtr free_func, IntPtr user_data)
	{
		void* user_data2 = user_data.ToPointer();
		ImGuiNative.igSetAllocatorFunctions(alloc_func, free_func, user_data2);
	}

	public unsafe static void SetClipboardText(string text)
	{
		int num = 0;
		byte* ptr;
		if (text != null)
		{
			num = Encoding.UTF8.GetByteCount(text);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(text, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igSetClipboardText(ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public static void SetColorEditOptions(ImGuiColorEditFlags flags)
	{
		ImGuiNative.igSetColorEditOptions(flags);
	}

	public static void SetColumnOffset(int column_index, float offset_x)
	{
		ImGuiNative.igSetColumnOffset(column_index, offset_x);
	}

	public static void SetColumnWidth(int column_index, float width)
	{
		ImGuiNative.igSetColumnWidth(column_index, width);
	}

	public static void SetCurrentContext(IntPtr ctx)
	{
		ImGuiNative.igSetCurrentContext(ctx);
	}

	public static void SetCursorPos(Vector2 local_pos)
	{
		ImGuiNative.igSetCursorPos(local_pos);
	}

	public static void SetCursorPosX(float local_x)
	{
		ImGuiNative.igSetCursorPosX(local_x);
	}

	public static void SetCursorPosY(float local_y)
	{
		ImGuiNative.igSetCursorPosY(local_y);
	}

	public static void SetCursorScreenPos(Vector2 pos)
	{
		ImGuiNative.igSetCursorScreenPos(pos);
	}

	public unsafe static bool SetDragDropPayload(string type, IntPtr data, uint sz)
	{
		int num = 0;
		byte* ptr;
		if (type != null)
		{
			num = Encoding.UTF8.GetByteCount(type);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(type, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* data2 = data.ToPointer();
		ImGuiCond cond = ImGuiCond.None;
		byte num2 = ImGuiNative.igSetDragDropPayload(ptr, data2, sz, cond);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool SetDragDropPayload(string type, IntPtr data, uint sz, ImGuiCond cond)
	{
		int num = 0;
		byte* ptr;
		if (type != null)
		{
			num = Encoding.UTF8.GetByteCount(type);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(type, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* data2 = data.ToPointer();
		byte num2 = ImGuiNative.igSetDragDropPayload(ptr, data2, sz, cond);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public static void SetItemAllowOverlap()
	{
		ImGuiNative.igSetItemAllowOverlap();
	}

	public static void SetItemDefaultFocus()
	{
		ImGuiNative.igSetItemDefaultFocus();
	}

	public static void SetKeyboardFocusHere()
	{
		ImGuiNative.igSetKeyboardFocusHere(0);
	}

	public static void SetKeyboardFocusHere(int offset)
	{
		ImGuiNative.igSetKeyboardFocusHere(offset);
	}

	public static void SetMouseCursor(ImGuiMouseCursor cursor_type)
	{
		ImGuiNative.igSetMouseCursor(cursor_type);
	}

	public static void SetNextFrameWantCaptureKeyboard(bool want_capture_keyboard)
	{
		ImGuiNative.igSetNextFrameWantCaptureKeyboard((byte)(want_capture_keyboard ? 1 : 0));
	}

	public static void SetNextFrameWantCaptureMouse(bool want_capture_mouse)
	{
		ImGuiNative.igSetNextFrameWantCaptureMouse((byte)(want_capture_mouse ? 1 : 0));
	}

	public static void SetNextItemOpen(bool is_open)
	{
		int is_open2 = (is_open ? 1 : 0);
		ImGuiCond cond = ImGuiCond.None;
		ImGuiNative.igSetNextItemOpen((byte)is_open2, cond);
	}

	public static void SetNextItemOpen(bool is_open, ImGuiCond cond)
	{
		ImGuiNative.igSetNextItemOpen((byte)(is_open ? 1 : 0), cond);
	}

	public static void SetNextItemWidth(float item_width)
	{
		ImGuiNative.igSetNextItemWidth(item_width);
	}

	public static void SetNextWindowBgAlpha(float alpha)
	{
		ImGuiNative.igSetNextWindowBgAlpha(alpha);
	}

	public unsafe static void SetNextWindowClass(ImGuiWindowClassPtr window_class)
	{
		ImGuiNative.igSetNextWindowClass(window_class.NativePtr);
	}

	public static void SetNextWindowCollapsed(bool collapsed)
	{
		int collapsed2 = (collapsed ? 1 : 0);
		ImGuiCond cond = ImGuiCond.None;
		ImGuiNative.igSetNextWindowCollapsed((byte)collapsed2, cond);
	}

	public static void SetNextWindowCollapsed(bool collapsed, ImGuiCond cond)
	{
		ImGuiNative.igSetNextWindowCollapsed((byte)(collapsed ? 1 : 0), cond);
	}

	public static void SetNextWindowContentSize(Vector2 size)
	{
		ImGuiNative.igSetNextWindowContentSize(size);
	}

	public static void SetNextWindowDockID(uint dock_id)
	{
		ImGuiCond cond = ImGuiCond.None;
		ImGuiNative.igSetNextWindowDockID(dock_id, cond);
	}

	public static void SetNextWindowDockID(uint dock_id, ImGuiCond cond)
	{
		ImGuiNative.igSetNextWindowDockID(dock_id, cond);
	}

	public static void SetNextWindowFocus()
	{
		ImGuiNative.igSetNextWindowFocus();
	}

	public static void SetNextWindowPos(Vector2 pos)
	{
		ImGuiCond cond = ImGuiCond.None;
		ImGuiNative.igSetNextWindowPos(pos, cond, default(Vector2));
	}

	public static void SetNextWindowPos(Vector2 pos, ImGuiCond cond)
	{
		ImGuiNative.igSetNextWindowPos(pos, cond, default(Vector2));
	}

	public static void SetNextWindowPos(Vector2 pos, ImGuiCond cond, Vector2 pivot)
	{
		ImGuiNative.igSetNextWindowPos(pos, cond, pivot);
	}

	public static void SetNextWindowScroll(Vector2 scroll)
	{
		ImGuiNative.igSetNextWindowScroll(scroll);
	}

	public static void SetNextWindowSize(Vector2 size)
	{
		ImGuiCond cond = ImGuiCond.None;
		ImGuiNative.igSetNextWindowSize(size, cond);
	}

	public static void SetNextWindowSize(Vector2 size, ImGuiCond cond)
	{
		ImGuiNative.igSetNextWindowSize(size, cond);
	}

	public unsafe static void SetNextWindowSizeConstraints(Vector2 size_min, Vector2 size_max)
	{
		ImGuiSizeCallback custom_callback = null;
		void* custom_callback_data = null;
		ImGuiNative.igSetNextWindowSizeConstraints(size_min, size_max, custom_callback, custom_callback_data);
	}

	public unsafe static void SetNextWindowSizeConstraints(Vector2 size_min, Vector2 size_max, ImGuiSizeCallback custom_callback)
	{
		void* custom_callback_data = null;
		ImGuiNative.igSetNextWindowSizeConstraints(size_min, size_max, custom_callback, custom_callback_data);
	}

	public unsafe static void SetNextWindowSizeConstraints(Vector2 size_min, Vector2 size_max, ImGuiSizeCallback custom_callback, IntPtr custom_callback_data)
	{
		void* custom_callback_data2 = custom_callback_data.ToPointer();
		ImGuiNative.igSetNextWindowSizeConstraints(size_min, size_max, custom_callback, custom_callback_data2);
	}

	public static void SetNextWindowViewport(uint viewport_id)
	{
		ImGuiNative.igSetNextWindowViewport(viewport_id);
	}

	public static void SetScrollFromPosX(float local_x)
	{
		float center_x_ratio = 0.5f;
		ImGuiNative.igSetScrollFromPosX_Float(local_x, center_x_ratio);
	}

	public static void SetScrollFromPosX(float local_x, float center_x_ratio)
	{
		ImGuiNative.igSetScrollFromPosX_Float(local_x, center_x_ratio);
	}

	public static void SetScrollFromPosY(float local_y)
	{
		float center_y_ratio = 0.5f;
		ImGuiNative.igSetScrollFromPosY_Float(local_y, center_y_ratio);
	}

	public static void SetScrollFromPosY(float local_y, float center_y_ratio)
	{
		ImGuiNative.igSetScrollFromPosY_Float(local_y, center_y_ratio);
	}

	public static void SetScrollHereX()
	{
		ImGuiNative.igSetScrollHereX(0.5f);
	}

	public static void SetScrollHereX(float center_x_ratio)
	{
		ImGuiNative.igSetScrollHereX(center_x_ratio);
	}

	public static void SetScrollHereY()
	{
		ImGuiNative.igSetScrollHereY(0.5f);
	}

	public static void SetScrollHereY(float center_y_ratio)
	{
		ImGuiNative.igSetScrollHereY(center_y_ratio);
	}

	public static void SetScrollX(float scroll_x)
	{
		ImGuiNative.igSetScrollX_Float(scroll_x);
	}

	public static void SetScrollY(float scroll_y)
	{
		ImGuiNative.igSetScrollY_Float(scroll_y);
	}

	public unsafe static void SetStateStorage(ImGuiStoragePtr storage)
	{
		ImGuiNative.igSetStateStorage(storage.NativePtr);
	}

	public unsafe static void SetTabItemClosed(string tab_or_docked_window_label)
	{
		int num = 0;
		byte* ptr;
		if (tab_or_docked_window_label != null)
		{
			num = Encoding.UTF8.GetByteCount(tab_or_docked_window_label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(tab_or_docked_window_label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igSetTabItemClosed(ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static void SetTooltip(string fmt)
	{
		int num = 0;
		byte* ptr;
		if (fmt != null)
		{
			num = Encoding.UTF8.GetByteCount(fmt);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(fmt, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igSetTooltip(ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public static void SetWindowCollapsed(bool collapsed)
	{
		int collapsed2 = (collapsed ? 1 : 0);
		ImGuiCond cond = ImGuiCond.None;
		ImGuiNative.igSetWindowCollapsed_Bool((byte)collapsed2, cond);
	}

	public static void SetWindowCollapsed(bool collapsed, ImGuiCond cond)
	{
		ImGuiNative.igSetWindowCollapsed_Bool((byte)(collapsed ? 1 : 0), cond);
	}

	public unsafe static void SetWindowCollapsed(string name, bool collapsed)
	{
		int num = 0;
		byte* ptr;
		if (name != null)
		{
			num = Encoding.UTF8.GetByteCount(name);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(name, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte collapsed2 = (byte)(collapsed ? 1 : 0);
		ImGuiCond cond = ImGuiCond.None;
		ImGuiNative.igSetWindowCollapsed_Str(ptr, collapsed2, cond);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static void SetWindowCollapsed(string name, bool collapsed, ImGuiCond cond)
	{
		int num = 0;
		byte* ptr;
		if (name != null)
		{
			num = Encoding.UTF8.GetByteCount(name);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(name, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte collapsed2 = (byte)(collapsed ? 1 : 0);
		ImGuiNative.igSetWindowCollapsed_Str(ptr, collapsed2, cond);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public static void SetWindowFocus()
	{
		ImGuiNative.igSetWindowFocus_Nil();
	}

	public unsafe static void SetWindowFocus(string name)
	{
		int num = 0;
		byte* ptr;
		if (name != null)
		{
			num = Encoding.UTF8.GetByteCount(name);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(name, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igSetWindowFocus_Str(ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public static void SetWindowFontScale(float scale)
	{
		ImGuiNative.igSetWindowFontScale(scale);
	}

	public static void SetWindowPos(Vector2 pos)
	{
		ImGuiCond cond = ImGuiCond.None;
		ImGuiNative.igSetWindowPos_Vec2(pos, cond);
	}

	public static void SetWindowPos(Vector2 pos, ImGuiCond cond)
	{
		ImGuiNative.igSetWindowPos_Vec2(pos, cond);
	}

	public unsafe static void SetWindowPos(string name, Vector2 pos)
	{
		int num = 0;
		byte* ptr;
		if (name != null)
		{
			num = Encoding.UTF8.GetByteCount(name);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(name, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiCond cond = ImGuiCond.None;
		ImGuiNative.igSetWindowPos_Str(ptr, pos, cond);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static void SetWindowPos(string name, Vector2 pos, ImGuiCond cond)
	{
		int num = 0;
		byte* ptr;
		if (name != null)
		{
			num = Encoding.UTF8.GetByteCount(name);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(name, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igSetWindowPos_Str(ptr, pos, cond);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public static void SetWindowSize(Vector2 size)
	{
		ImGuiCond cond = ImGuiCond.None;
		ImGuiNative.igSetWindowSize_Vec2(size, cond);
	}

	public static void SetWindowSize(Vector2 size, ImGuiCond cond)
	{
		ImGuiNative.igSetWindowSize_Vec2(size, cond);
	}

	public unsafe static void SetWindowSize(string name, Vector2 size)
	{
		int num = 0;
		byte* ptr;
		if (name != null)
		{
			num = Encoding.UTF8.GetByteCount(name);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(name, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiCond cond = ImGuiCond.None;
		ImGuiNative.igSetWindowSize_Str(ptr, size, cond);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static void SetWindowSize(string name, Vector2 size, ImGuiCond cond)
	{
		int num = 0;
		byte* ptr;
		if (name != null)
		{
			num = Encoding.UTF8.GetByteCount(name);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(name, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igSetWindowSize_Str(ptr, size, cond);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static void ShowAboutWindow()
	{
		byte* p_open = null;
		ImGuiNative.igShowAboutWindow(p_open);
	}

	public unsafe static void ShowAboutWindow(ref bool p_open)
	{
		byte b = (byte)(p_open ? 1 : 0);
		ImGuiNative.igShowAboutWindow(&b);
		p_open = b != 0;
	}

	public unsafe static void ShowDebugLogWindow()
	{
		byte* p_open = null;
		ImGuiNative.igShowDebugLogWindow(p_open);
	}

	public unsafe static void ShowDebugLogWindow(ref bool p_open)
	{
		byte b = (byte)(p_open ? 1 : 0);
		ImGuiNative.igShowDebugLogWindow(&b);
		p_open = b != 0;
	}

	public unsafe static void ShowDemoWindow()
	{
		byte* p_open = null;
		ImGuiNative.igShowDemoWindow(p_open);
	}

	public unsafe static void ShowDemoWindow(ref bool p_open)
	{
		byte b = (byte)(p_open ? 1 : 0);
		ImGuiNative.igShowDemoWindow(&b);
		p_open = b != 0;
	}

	public unsafe static void ShowFontSelector(string label)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igShowFontSelector(ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static void ShowMetricsWindow()
	{
		byte* p_open = null;
		ImGuiNative.igShowMetricsWindow(p_open);
	}

	public unsafe static void ShowMetricsWindow(ref bool p_open)
	{
		byte b = (byte)(p_open ? 1 : 0);
		ImGuiNative.igShowMetricsWindow(&b);
		p_open = b != 0;
	}

	public unsafe static void ShowStackToolWindow()
	{
		byte* p_open = null;
		ImGuiNative.igShowStackToolWindow(p_open);
	}

	public unsafe static void ShowStackToolWindow(ref bool p_open)
	{
		byte b = (byte)(p_open ? 1 : 0);
		ImGuiNative.igShowStackToolWindow(&b);
		p_open = b != 0;
	}

	public unsafe static void ShowStyleEditor()
	{
		ImGuiStyle* @ref = null;
		ImGuiNative.igShowStyleEditor(@ref);
	}

	public unsafe static void ShowStyleEditor(ImGuiStylePtr @ref)
	{
		ImGuiNative.igShowStyleEditor(@ref.NativePtr);
	}

	public unsafe static bool ShowStyleSelector(string label)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igShowStyleSelector(ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public static void ShowUserGuide()
	{
		ImGuiNative.igShowUserGuide();
	}

	public unsafe static bool SliderAngle(string label, ref float v_rad)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float v_degrees_min = -360f;
		float v_degrees_max = 360f;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.0f deg");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.0f deg", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (float* v_rad2 = &v_rad)
		{
			byte num3 = ImGuiNative.igSliderAngle(ptr, v_rad2, v_degrees_min, v_degrees_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderAngle(string label, ref float v_rad, float v_degrees_min)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float v_degrees_max = 360f;
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.0f deg");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.0f deg", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (float* v_rad2 = &v_rad)
		{
			byte num3 = ImGuiNative.igSliderAngle(ptr, v_rad2, v_degrees_min, v_degrees_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderAngle(string label, ref float v_rad, float v_degrees_min, float v_degrees_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.0f deg");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.0f deg", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (float* v_rad2 = &v_rad)
		{
			byte num3 = ImGuiNative.igSliderAngle(ptr, v_rad2, v_degrees_min, v_degrees_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderAngle(string label, ref float v_rad, float v_degrees_min, float v_degrees_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (float* v_rad2 = &v_rad)
		{
			byte num3 = ImGuiNative.igSliderAngle(ptr, v_rad2, v_degrees_min, v_degrees_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderAngle(string label, ref float v_rad, float v_degrees_min, float v_degrees_max, string format, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (float* v_rad2 = &v_rad)
		{
			byte num3 = ImGuiNative.igSliderAngle(ptr, v_rad2, v_degrees_min, v_degrees_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderFloat(string label, ref float v, float v_min, float v_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (float* v2 = &v)
		{
			byte num3 = ImGuiNative.igSliderFloat(ptr, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderFloat(string label, ref float v, float v_min, float v_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (float* v2 = &v)
		{
			byte num3 = ImGuiNative.igSliderFloat(ptr, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderFloat(string label, ref float v, float v_min, float v_max, string format, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (float* v2 = &v)
		{
			byte num3 = ImGuiNative.igSliderFloat(ptr, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderFloat2(string label, ref Vector2 v, float v_min, float v_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (Vector2* v2 = &v)
		{
			byte num3 = ImGuiNative.igSliderFloat2(ptr, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderFloat2(string label, ref Vector2 v, float v_min, float v_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (Vector2* v2 = &v)
		{
			byte num3 = ImGuiNative.igSliderFloat2(ptr, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderFloat2(string label, ref Vector2 v, float v_min, float v_max, string format, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (Vector2* v2 = &v)
		{
			byte num3 = ImGuiNative.igSliderFloat2(ptr, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderFloat3(string label, ref Vector3 v, float v_min, float v_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (Vector3* v2 = &v)
		{
			byte num3 = ImGuiNative.igSliderFloat3(ptr, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderFloat3(string label, ref Vector3 v, float v_min, float v_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (Vector3* v2 = &v)
		{
			byte num3 = ImGuiNative.igSliderFloat3(ptr, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderFloat3(string label, ref Vector3 v, float v_min, float v_max, string format, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (Vector3* v2 = &v)
		{
			byte num3 = ImGuiNative.igSliderFloat3(ptr, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderFloat4(string label, ref Vector4 v, float v_min, float v_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (Vector4* v2 = &v)
		{
			byte num3 = ImGuiNative.igSliderFloat4(ptr, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderFloat4(string label, ref Vector4 v, float v_min, float v_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (Vector4* v2 = &v)
		{
			byte num3 = ImGuiNative.igSliderFloat4(ptr, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderFloat4(string label, ref Vector4 v, float v_min, float v_max, string format, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (Vector4* v2 = &v)
		{
			byte num3 = ImGuiNative.igSliderFloat4(ptr, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderInt(string label, ref int v, int v_min, int v_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%d");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%d", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igSliderInt(ptr, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderInt(string label, ref int v, int v_min, int v_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igSliderInt(ptr, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderInt(string label, ref int v, int v_min, int v_max, string format, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igSliderInt(ptr, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderInt2(string label, ref int v, int v_min, int v_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%d");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%d", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igSliderInt2(ptr, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderInt2(string label, ref int v, int v_min, int v_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igSliderInt2(ptr, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderInt2(string label, ref int v, int v_min, int v_max, string format, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igSliderInt2(ptr, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderInt3(string label, ref int v, int v_min, int v_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%d");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%d", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igSliderInt3(ptr, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderInt3(string label, ref int v, int v_min, int v_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igSliderInt3(ptr, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderInt3(string label, ref int v, int v_min, int v_max, string format, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igSliderInt3(ptr, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderInt4(string label, ref int v, int v_min, int v_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%d");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%d", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igSliderInt4(ptr, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderInt4(string label, ref int v, int v_min, int v_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igSliderInt4(ptr, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderInt4(string label, ref int v, int v_min, int v_max, string format, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igSliderInt4(ptr, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool SliderScalar(string label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_min, IntPtr p_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_min2 = p_min.ToPointer();
		void* p_max2 = p_max.ToPointer();
		byte* format = null;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		byte num2 = ImGuiNative.igSliderScalar(ptr, data_type, p_data2, p_min2, p_max2, format, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool SliderScalar(string label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_min, IntPtr p_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_min2 = p_min.ToPointer();
		void* p_max2 = p_max.ToPointer();
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		byte num3 = ImGuiNative.igSliderScalar(ptr, data_type, p_data2, p_min2, p_max2, ptr2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
		return num3 != 0;
	}

	public unsafe static bool SliderScalar(string label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_min, IntPtr p_max, string format, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_min2 = p_min.ToPointer();
		void* p_max2 = p_max.ToPointer();
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		byte num3 = ImGuiNative.igSliderScalar(ptr, data_type, p_data2, p_min2, p_max2, ptr2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
		return num3 != 0;
	}

	public unsafe static bool SliderScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components, IntPtr p_min, IntPtr p_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_min2 = p_min.ToPointer();
		void* p_max2 = p_max.ToPointer();
		byte* format = null;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		byte num2 = ImGuiNative.igSliderScalarN(ptr, data_type, p_data2, components, p_min2, p_max2, format, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool SliderScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components, IntPtr p_min, IntPtr p_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_min2 = p_min.ToPointer();
		void* p_max2 = p_max.ToPointer();
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		byte num3 = ImGuiNative.igSliderScalarN(ptr, data_type, p_data2, components, p_min2, p_max2, ptr2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
		return num3 != 0;
	}

	public unsafe static bool SliderScalarN(string label, ImGuiDataType data_type, IntPtr p_data, int components, IntPtr p_min, IntPtr p_max, string format, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_min2 = p_min.ToPointer();
		void* p_max2 = p_max.ToPointer();
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		byte num3 = ImGuiNative.igSliderScalarN(ptr, data_type, p_data2, components, p_min2, p_max2, ptr2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
		return num3 != 0;
	}

	public unsafe static bool SmallButton(string label)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igSmallButton(ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public static void Spacing()
	{
		ImGuiNative.igSpacing();
	}

	public unsafe static void StyleColorsClassic()
	{
		ImGuiStyle* dst = null;
		ImGuiNative.igStyleColorsClassic(dst);
	}

	public unsafe static void StyleColorsClassic(ImGuiStylePtr dst)
	{
		ImGuiNative.igStyleColorsClassic(dst.NativePtr);
	}

	public unsafe static void StyleColorsDark()
	{
		ImGuiStyle* dst = null;
		ImGuiNative.igStyleColorsDark(dst);
	}

	public unsafe static void StyleColorsDark(ImGuiStylePtr dst)
	{
		ImGuiNative.igStyleColorsDark(dst.NativePtr);
	}

	public unsafe static void StyleColorsLight()
	{
		ImGuiStyle* dst = null;
		ImGuiNative.igStyleColorsLight(dst);
	}

	public unsafe static void StyleColorsLight(ImGuiStylePtr dst)
	{
		ImGuiNative.igStyleColorsLight(dst.NativePtr);
	}

	public unsafe static bool TabItemButton(string label)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiTabItemFlags flags = ImGuiTabItemFlags.None;
		byte num2 = ImGuiNative.igTabItemButton(ptr, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool TabItemButton(string label, ImGuiTabItemFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igTabItemButton(ptr, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public static int TableGetColumnCount()
	{
		return ImGuiNative.igTableGetColumnCount();
	}

	public static ImGuiTableColumnFlags TableGetColumnFlags()
	{
		return ImGuiNative.igTableGetColumnFlags(-1);
	}

	public static ImGuiTableColumnFlags TableGetColumnFlags(int column_n)
	{
		return ImGuiNative.igTableGetColumnFlags(column_n);
	}

	public static int TableGetColumnIndex()
	{
		return ImGuiNative.igTableGetColumnIndex();
	}

	public unsafe static string TableGetColumnName()
	{
		return Util.StringFromPtr(ImGuiNative.igTableGetColumnName_Int(-1));
	}

	public unsafe static string TableGetColumnName(int column_n)
	{
		return Util.StringFromPtr(ImGuiNative.igTableGetColumnName_Int(column_n));
	}

	public static int TableGetRowIndex()
	{
		return ImGuiNative.igTableGetRowIndex();
	}

	public unsafe static ImGuiTableSortSpecsPtr TableGetSortSpecs()
	{
		return new ImGuiTableSortSpecsPtr(ImGuiNative.igTableGetSortSpecs());
	}

	public unsafe static void TableHeader(string label)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igTableHeader(ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public static void TableHeadersRow()
	{
		ImGuiNative.igTableHeadersRow();
	}

	public static bool TableNextColumn()
	{
		return ImGuiNative.igTableNextColumn() != 0;
	}

	public static void TableNextRow()
	{
		float min_row_height = 0f;
		ImGuiNative.igTableNextRow(ImGuiTableRowFlags.None, min_row_height);
	}

	public static void TableNextRow(ImGuiTableRowFlags row_flags)
	{
		float min_row_height = 0f;
		ImGuiNative.igTableNextRow(row_flags, min_row_height);
	}

	public static void TableNextRow(ImGuiTableRowFlags row_flags, float min_row_height)
	{
		ImGuiNative.igTableNextRow(row_flags, min_row_height);
	}

	public static void TableSetBgColor(ImGuiTableBgTarget target, uint color)
	{
		int column_n = -1;
		ImGuiNative.igTableSetBgColor(target, color, column_n);
	}

	public static void TableSetBgColor(ImGuiTableBgTarget target, uint color, int column_n)
	{
		ImGuiNative.igTableSetBgColor(target, color, column_n);
	}

	public static void TableSetColumnEnabled(int column_n, bool v)
	{
		byte v2 = (byte)(v ? 1 : 0);
		ImGuiNative.igTableSetColumnEnabled(column_n, v2);
	}

	public static bool TableSetColumnIndex(int column_n)
	{
		return ImGuiNative.igTableSetColumnIndex(column_n) != 0;
	}

	public unsafe static void TableSetupColumn(string label)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiTableColumnFlags flags = ImGuiTableColumnFlags.None;
		float init_width_or_weight = 0f;
		uint user_id = 0u;
		ImGuiNative.igTableSetupColumn(ptr, flags, init_width_or_weight, user_id);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static void TableSetupColumn(string label, ImGuiTableColumnFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float init_width_or_weight = 0f;
		uint user_id = 0u;
		ImGuiNative.igTableSetupColumn(ptr, flags, init_width_or_weight, user_id);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static void TableSetupColumn(string label, ImGuiTableColumnFlags flags, float init_width_or_weight)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		uint user_id = 0u;
		ImGuiNative.igTableSetupColumn(ptr, flags, init_width_or_weight, user_id);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static void TableSetupColumn(string label, ImGuiTableColumnFlags flags, float init_width_or_weight, uint user_id)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igTableSetupColumn(ptr, flags, init_width_or_weight, user_id);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public static void TableSetupScrollFreeze(int cols, int rows)
	{
		ImGuiNative.igTableSetupScrollFreeze(cols, rows);
	}

	public unsafe static void Text(string fmt)
	{
		int num = 0;
		byte* ptr;
		if (fmt != null)
		{
			num = Encoding.UTF8.GetByteCount(fmt);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(fmt, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igText(ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static void TextColored(Vector4 col, string fmt)
	{
		int num = 0;
		byte* ptr;
		if (fmt != null)
		{
			num = Encoding.UTF8.GetByteCount(fmt);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(fmt, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igTextColored(col, ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static void TextDisabled(string fmt)
	{
		int num = 0;
		byte* ptr;
		if (fmt != null)
		{
			num = Encoding.UTF8.GetByteCount(fmt);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(fmt, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igTextDisabled(ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static void TextUnformatted(string text)
	{
		int num = 0;
		byte* ptr;
		if (text != null)
		{
			num = Encoding.UTF8.GetByteCount(text);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(text, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte* text_end = null;
		ImGuiNative.igTextUnformatted(ptr, text_end);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static void TextWrapped(string fmt)
	{
		int num = 0;
		byte* ptr;
		if (fmt != null)
		{
			num = Encoding.UTF8.GetByteCount(fmt);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(fmt, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igTextWrapped(ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static bool TreeNode(string label)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igTreeNode_Str(ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool TreeNode(string str_id, string fmt)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (fmt != null)
		{
			num2 = Encoding.UTF8.GetByteCount(fmt);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(fmt, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		byte num3 = ImGuiNative.igTreeNode_StrStr(ptr, ptr2);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
		return num3 != 0;
	}

	public unsafe static bool TreeNode(IntPtr ptr_id, string fmt)
	{
		void* ptr_id2 = ptr_id.ToPointer();
		int num = 0;
		byte* ptr;
		if (fmt != null)
		{
			num = Encoding.UTF8.GetByteCount(fmt);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(fmt, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igTreeNode_Ptr(ptr_id2, ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool TreeNodeEx(string label)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags.None;
		byte num2 = ImGuiNative.igTreeNodeEx_Str(ptr, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool TreeNodeEx(string label, ImGuiTreeNodeFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igTreeNodeEx_Str(ptr, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool TreeNodeEx(string str_id, ImGuiTreeNodeFlags flags, string fmt)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (fmt != null)
		{
			num2 = Encoding.UTF8.GetByteCount(fmt);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(fmt, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		byte num3 = ImGuiNative.igTreeNodeEx_StrStr(ptr, flags, ptr2);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
		return num3 != 0;
	}

	public unsafe static bool TreeNodeEx(IntPtr ptr_id, ImGuiTreeNodeFlags flags, string fmt)
	{
		void* ptr_id2 = ptr_id.ToPointer();
		int num = 0;
		byte* ptr;
		if (fmt != null)
		{
			num = Encoding.UTF8.GetByteCount(fmt);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(fmt, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.igTreeNodeEx_Ptr(ptr_id2, flags, ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public static void TreePop()
	{
		ImGuiNative.igTreePop();
	}

	public unsafe static void TreePush(string str_id)
	{
		int num = 0;
		byte* ptr;
		if (str_id != null)
		{
			num = Encoding.UTF8.GetByteCount(str_id);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str_id, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igTreePush_Str(ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static void TreePush(IntPtr ptr_id)
	{
		ImGuiNative.igTreePush_Ptr(ptr_id.ToPointer());
	}

	public static void Unindent()
	{
		ImGuiNative.igUnindent(0f);
	}

	public static void Unindent(float indent_w)
	{
		ImGuiNative.igUnindent(indent_w);
	}

	public static void UpdatePlatformWindows()
	{
		ImGuiNative.igUpdatePlatformWindows();
	}

	public unsafe static void Value(string prefix, bool b)
	{
		int num = 0;
		byte* ptr;
		if (prefix != null)
		{
			num = Encoding.UTF8.GetByteCount(prefix);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(prefix, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte b2 = (byte)(b ? 1 : 0);
		ImGuiNative.igValue_Bool(ptr, b2);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static void Value(string prefix, int v)
	{
		int num = 0;
		byte* ptr;
		if (prefix != null)
		{
			num = Encoding.UTF8.GetByteCount(prefix);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(prefix, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igValue_Int(ptr, v);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static void Value(string prefix, uint v)
	{
		int num = 0;
		byte* ptr;
		if (prefix != null)
		{
			num = Encoding.UTF8.GetByteCount(prefix);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(prefix, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.igValue_Uint(ptr, v);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static void Value(string prefix, float v)
	{
		int num = 0;
		byte* ptr;
		if (prefix != null)
		{
			num = Encoding.UTF8.GetByteCount(prefix);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(prefix, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte* float_format = null;
		ImGuiNative.igValue_Float(ptr, v, float_format);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe static void Value(string prefix, float v, string float_format)
	{
		int num = 0;
		byte* ptr;
		if (prefix != null)
		{
			num = Encoding.UTF8.GetByteCount(prefix);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(prefix, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (float_format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(float_format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(float_format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiNative.igValue_Float(ptr, v, ptr2);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
	}

	public unsafe static bool VSliderFloat(string label, Vector2 size, ref float v, float v_min, float v_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%.3f");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%.3f", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (float* v2 = &v)
		{
			byte num3 = ImGuiNative.igVSliderFloat(ptr, size, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool VSliderFloat(string label, Vector2 size, ref float v, float v_min, float v_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (float* v2 = &v)
		{
			byte num3 = ImGuiNative.igVSliderFloat(ptr, size, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool VSliderFloat(string label, Vector2 size, ref float v, float v_min, float v_max, string format, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (float* v2 = &v)
		{
			byte num3 = ImGuiNative.igVSliderFloat(ptr, size, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool VSliderInt(string label, Vector2 size, ref int v, int v_min, int v_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		num2 = Encoding.UTF8.GetByteCount("%d");
		byte* ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
		int utf2 = Util.GetUtf8("%d", ptr2, num2);
		ptr2[utf2] = 0;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igVSliderInt(ptr, size, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool VSliderInt(string label, Vector2 size, ref int v, int v_min, int v_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igVSliderInt(ptr, size, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool VSliderInt(string label, Vector2 size, ref int v, int v_min, int v_max, string format, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		fixed (int* v2 = &v)
		{
			byte num3 = ImGuiNative.igVSliderInt(ptr, size, v2, v_min, v_max, ptr2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr2);
			}
			return num3 != 0;
		}
	}

	public unsafe static bool VSliderScalar(string label, Vector2 size, ImGuiDataType data_type, IntPtr p_data, IntPtr p_min, IntPtr p_max)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_min2 = p_min.ToPointer();
		void* p_max2 = p_max.ToPointer();
		byte* format = null;
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		byte num2 = ImGuiNative.igVSliderScalar(ptr, size, data_type, p_data2, p_min2, p_max2, format, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe static bool VSliderScalar(string label, Vector2 size, ImGuiDataType data_type, IntPtr p_data, IntPtr p_min, IntPtr p_max, string format)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_min2 = p_min.ToPointer();
		void* p_max2 = p_max.ToPointer();
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		ImGuiSliderFlags flags = ImGuiSliderFlags.None;
		byte num3 = ImGuiNative.igVSliderScalar(ptr, size, data_type, p_data2, p_min2, p_max2, ptr2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
		return num3 != 0;
	}

	public unsafe static bool VSliderScalar(string label, Vector2 size, ImGuiDataType data_type, IntPtr p_data, IntPtr p_min, IntPtr p_max, string format, ImGuiSliderFlags flags)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		void* p_data2 = p_data.ToPointer();
		void* p_min2 = p_min.ToPointer();
		void* p_max2 = p_max.ToPointer();
		int num2 = 0;
		byte* ptr2;
		if (format != null)
		{
			num2 = Encoding.UTF8.GetByteCount(format);
			ptr2 = ((num2 <= 2048) ? stackalloc byte[(int)(uint)(num2 + 1)] : Util.Allocate(num2 + 1));
			int utf2 = Util.GetUtf8(format, ptr2, num2);
			ptr2[utf2] = 0;
		}
		else
		{
			ptr2 = null;
		}
		byte num3 = ImGuiNative.igVSliderScalar(ptr, size, data_type, p_data2, p_min2, p_max2, ptr2, flags);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		if (num2 > 2048)
		{
			Util.Free(ptr2);
		}
		return num3 != 0;
	}

	public static bool InputText(string label, byte[] buf, uint buf_size)
	{
		return InputText(label, buf, buf_size, ImGuiInputTextFlags.None, null, IntPtr.Zero);
	}

	public static bool InputText(string label, byte[] buf, uint buf_size, ImGuiInputTextFlags flags)
	{
		return InputText(label, buf, buf_size, flags, null, IntPtr.Zero);
	}

	public static bool InputText(string label, byte[] buf, uint buf_size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback)
	{
		return InputText(label, buf, buf_size, flags, callback, IntPtr.Zero);
	}

	public unsafe static bool InputText(string label, byte[] buf, uint buf_size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, IntPtr user_data)
	{
		int byteCount = Encoding.UTF8.GetByteCount(label);
		byte* ptr = ((byteCount <= 2048) ? stackalloc byte[(int)(uint)(byteCount + 1)] : Util.Allocate(byteCount + 1));
		Util.GetUtf8(label, ptr, byteCount);
		bool result;
		fixed (byte* buf2 = buf)
		{
			result = ImGuiNative.igInputText(ptr, buf2, buf_size, flags, callback, user_data.ToPointer()) != 0;
		}
		if (byteCount > 2048)
		{
			Util.Free(ptr);
		}
		return result;
	}

	public static bool InputText(string label, ref string input, uint maxLength)
	{
		return InputText(label, ref input, maxLength, ImGuiInputTextFlags.None, null, IntPtr.Zero);
	}

	public static bool InputText(string label, ref string input, uint maxLength, ImGuiInputTextFlags flags)
	{
		return InputText(label, ref input, maxLength, flags, null, IntPtr.Zero);
	}

	public static bool InputText(string label, ref string input, uint maxLength, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback)
	{
		return InputText(label, ref input, maxLength, flags, callback, IntPtr.Zero);
	}

	public unsafe static bool InputText(string label, ref string input, uint maxLength, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, IntPtr user_data)
	{
		int byteCount = Encoding.UTF8.GetByteCount(label);
		byte* ptr = ((byteCount <= 2048) ? stackalloc byte[(int)(uint)(byteCount + 1)] : Util.Allocate(byteCount + 1));
		Util.GetUtf8(label, ptr, byteCount);
		int byteCount2 = Encoding.UTF8.GetByteCount(input);
		int num = Math.Max((int)(maxLength + 1), byteCount2 + 1);
		byte* ptr2;
		byte* ptr3;
		if (num > 2048)
		{
			ptr2 = Util.Allocate(num);
			ptr3 = Util.Allocate(num);
		}
		else
		{
			ptr2 = stackalloc byte[(int)(uint)num];
			ptr3 = stackalloc byte[(int)(uint)num];
		}
		Util.GetUtf8(input, ptr2, num);
		uint byteCount3 = (uint)(num - byteCount2);
		Unsafe.InitBlockUnaligned(ptr2 + byteCount2, 0, byteCount3);
		Unsafe.CopyBlock(ptr3, ptr2, (uint)num);
		byte b = ImGuiNative.igInputText(ptr, ptr2, (uint)num, flags, callback, user_data.ToPointer());
		if (!Util.AreStringsEqual(ptr3, num, ptr2))
		{
			input = Util.StringFromPtr(ptr2);
		}
		if (byteCount > 2048)
		{
			Util.Free(ptr);
		}
		if (num > 2048)
		{
			Util.Free(ptr2);
			Util.Free(ptr3);
		}
		return b != 0;
	}

	public static bool InputTextMultiline(string label, ref string input, uint maxLength, Vector2 size)
	{
		return InputTextMultiline(label, ref input, maxLength, size, ImGuiInputTextFlags.None, null, IntPtr.Zero);
	}

	public static bool InputTextMultiline(string label, ref string input, uint maxLength, Vector2 size, ImGuiInputTextFlags flags)
	{
		return InputTextMultiline(label, ref input, maxLength, size, flags, null, IntPtr.Zero);
	}

	public static bool InputTextMultiline(string label, ref string input, uint maxLength, Vector2 size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback)
	{
		return InputTextMultiline(label, ref input, maxLength, size, flags, callback, IntPtr.Zero);
	}

	public unsafe static bool InputTextMultiline(string label, ref string input, uint maxLength, Vector2 size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, IntPtr user_data)
	{
		int byteCount = Encoding.UTF8.GetByteCount(label);
		byte* ptr = ((byteCount <= 2048) ? stackalloc byte[(int)(uint)(byteCount + 1)] : Util.Allocate(byteCount + 1));
		Util.GetUtf8(label, ptr, byteCount);
		int byteCount2 = Encoding.UTF8.GetByteCount(input);
		int num = Math.Max((int)(maxLength + 1), byteCount2 + 1);
		byte* ptr2;
		byte* ptr3;
		if (num > 2048)
		{
			ptr2 = Util.Allocate(num);
			ptr3 = Util.Allocate(num);
		}
		else
		{
			ptr2 = stackalloc byte[(int)(uint)num];
			ptr3 = stackalloc byte[(int)(uint)num];
		}
		Util.GetUtf8(input, ptr2, num);
		uint byteCount3 = (uint)(num - byteCount2);
		Unsafe.InitBlockUnaligned(ptr2 + byteCount2, 0, byteCount3);
		Unsafe.CopyBlock(ptr3, ptr2, (uint)num);
		byte b = ImGuiNative.igInputTextMultiline(ptr, ptr2, (uint)num, size, flags, callback, user_data.ToPointer());
		if (!Util.AreStringsEqual(ptr3, num, ptr2))
		{
			input = Util.StringFromPtr(ptr2);
		}
		if (byteCount > 2048)
		{
			Util.Free(ptr);
		}
		if (num > 2048)
		{
			Util.Free(ptr2);
			Util.Free(ptr3);
		}
		return b != 0;
	}

	public static bool InputTextWithHint(string label, string hint, ref string input, uint maxLength)
	{
		return InputTextWithHint(label, hint, ref input, maxLength, ImGuiInputTextFlags.None, null, IntPtr.Zero);
	}

	public static bool InputTextWithHint(string label, string hint, ref string input, uint maxLength, ImGuiInputTextFlags flags)
	{
		return InputTextWithHint(label, hint, ref input, maxLength, flags, null, IntPtr.Zero);
	}

	public static bool InputTextWithHint(string label, string hint, ref string input, uint maxLength, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback)
	{
		return InputTextWithHint(label, hint, ref input, maxLength, flags, callback, IntPtr.Zero);
	}

	public unsafe static bool InputTextWithHint(string label, string hint, ref string input, uint maxLength, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, IntPtr user_data)
	{
		int byteCount = Encoding.UTF8.GetByteCount(label);
		byte* ptr = ((byteCount <= 2048) ? stackalloc byte[(int)(uint)(byteCount + 1)] : Util.Allocate(byteCount + 1));
		Util.GetUtf8(label, ptr, byteCount);
		int byteCount2 = Encoding.UTF8.GetByteCount(hint);
		byte* ptr2 = ((byteCount2 <= 2048) ? stackalloc byte[(int)(uint)(byteCount2 + 1)] : Util.Allocate(byteCount2 + 1));
		Util.GetUtf8(hint, ptr2, byteCount2);
		int byteCount3 = Encoding.UTF8.GetByteCount(input);
		int num = Math.Max((int)(maxLength + 1), byteCount3 + 1);
		byte* ptr3;
		byte* ptr4;
		if (num > 2048)
		{
			ptr3 = Util.Allocate(num);
			ptr4 = Util.Allocate(num);
		}
		else
		{
			ptr3 = stackalloc byte[(int)(uint)num];
			ptr4 = stackalloc byte[(int)(uint)num];
		}
		Util.GetUtf8(input, ptr3, num);
		uint byteCount4 = (uint)(num - byteCount3);
		Unsafe.InitBlockUnaligned(ptr3 + byteCount3, 0, byteCount4);
		Unsafe.CopyBlock(ptr4, ptr3, (uint)num);
		byte b = ImGuiNative.igInputTextWithHint(ptr, ptr2, ptr3, (uint)num, flags, callback, user_data.ToPointer());
		if (!Util.AreStringsEqual(ptr4, num, ptr3))
		{
			input = Util.StringFromPtr(ptr3);
		}
		if (byteCount > 2048)
		{
			Util.Free(ptr);
		}
		if (byteCount2 > 2048)
		{
			Util.Free(ptr2);
		}
		if (num > 2048)
		{
			Util.Free(ptr3);
			Util.Free(ptr4);
		}
		return b != 0;
	}

	public static Vector2 CalcTextSize(string text)
	{
		return CalcTextSizeImpl(text);
	}

	public static Vector2 CalcTextSize(string text, int start)
	{
		return CalcTextSizeImpl(text, start);
	}

	public static Vector2 CalcTextSize(string text, float wrapWidth)
	{
		return CalcTextSizeImpl(text, 0, null, hideTextAfterDoubleHash: false, wrapWidth);
	}

	public static Vector2 CalcTextSize(string text, bool hideTextAfterDoubleHash)
	{
		bool hideTextAfterDoubleHash2 = hideTextAfterDoubleHash;
		return CalcTextSizeImpl(text, 0, null, hideTextAfterDoubleHash2);
	}

	public static Vector2 CalcTextSize(string text, int start, int length)
	{
		return CalcTextSizeImpl(text, start, length);
	}

	public static Vector2 CalcTextSize(string text, int start, bool hideTextAfterDoubleHash)
	{
		bool hideTextAfterDoubleHash2 = hideTextAfterDoubleHash;
		return CalcTextSizeImpl(text, start, null, hideTextAfterDoubleHash2);
	}

	public static Vector2 CalcTextSize(string text, int start, float wrapWidth)
	{
		return CalcTextSizeImpl(text, start, null, hideTextAfterDoubleHash: false, wrapWidth);
	}

	public static Vector2 CalcTextSize(string text, bool hideTextAfterDoubleHash, float wrapWidth)
	{
		bool hideTextAfterDoubleHash2 = hideTextAfterDoubleHash;
		return CalcTextSizeImpl(text, 0, null, hideTextAfterDoubleHash2, wrapWidth);
	}

	public static Vector2 CalcTextSize(string text, int start, int length, bool hideTextAfterDoubleHash)
	{
		return CalcTextSizeImpl(text, start, length, hideTextAfterDoubleHash);
	}

	public static Vector2 CalcTextSize(string text, int start, int length, float wrapWidth)
	{
		return CalcTextSizeImpl(text, start, length, hideTextAfterDoubleHash: false, wrapWidth);
	}

	public static Vector2 CalcTextSize(string text, int start, int length, bool hideTextAfterDoubleHash, float wrapWidth)
	{
		return CalcTextSizeImpl(text, start, length, hideTextAfterDoubleHash, wrapWidth);
	}

	private unsafe static Vector2 CalcTextSizeImpl(string text, int start = 0, int? length = null, bool hideTextAfterDoubleHash = false, float wrapWidth = -1f)
	{
		byte* ptr = null;
		byte* text_end = null;
		int num = 0;
		if (text != null)
		{
			int length2 = (length.HasValue ? length.Value : text.Length);
			num = Util.CalcSizeInUtf8(text, start, length2);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(text, start, length2, ptr, num);
			ptr[utf] = 0;
			text_end = ptr + utf;
		}
		Vector2 result = default(Vector2);
		ImGuiNative.igCalcTextSize(&result, ptr, text_end, hideTextAfterDoubleHash ? ((byte)1) : ((byte)0), wrapWidth);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return result;
	}

	public static bool InputText(string label, IntPtr buf, uint buf_size)
	{
		return InputText(label, buf, buf_size, ImGuiInputTextFlags.None, null, IntPtr.Zero);
	}

	public static bool InputText(string label, IntPtr buf, uint buf_size, ImGuiInputTextFlags flags)
	{
		return InputText(label, buf, buf_size, flags, null, IntPtr.Zero);
	}

	public static bool InputText(string label, IntPtr buf, uint buf_size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback)
	{
		return InputText(label, buf, buf_size, flags, callback, IntPtr.Zero);
	}

	public unsafe static bool InputText(string label, IntPtr buf, uint buf_size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, IntPtr user_data)
	{
		int byteCount = Encoding.UTF8.GetByteCount(label);
		byte* ptr = ((byteCount <= 2048) ? stackalloc byte[(int)(uint)(byteCount + 1)] : Util.Allocate(byteCount + 1));
		Util.GetUtf8(label, ptr, byteCount);
		bool result = ImGuiNative.igInputText(ptr, (byte*)buf.ToPointer(), buf_size, flags, callback, user_data.ToPointer()) != 0;
		if (byteCount > 2048)
		{
			Util.Free(ptr);
		}
		return result;
	}

	public unsafe static bool Begin(string name, ImGuiWindowFlags flags)
	{
		int byteCount = Encoding.UTF8.GetByteCount(name);
		byte* ptr = ((byteCount <= 2048) ? stackalloc byte[(int)(uint)(byteCount + 1)] : Util.Allocate(byteCount + 1));
		Util.GetUtf8(name, ptr, byteCount);
		byte* p_open = null;
		byte num = ImGuiNative.igBegin(ptr, p_open, flags);
		if (byteCount > 2048)
		{
			Util.Free(ptr);
		}
		return num != 0;
	}

	public static bool MenuItem(string label, bool enabled)
	{
		return MenuItem(label, string.Empty, selected: false, enabled);
	}
}
[Flags]
public enum ImGuiBackendFlags
{
	None = 0,
	HasGamepad = 1,
	HasMouseCursors = 2,
	HasSetMousePos = 4,
	RendererHasVtxOffset = 8,
	PlatformHasViewports = 0x400,
	HasMouseHoveredViewport = 0x800,
	RendererHasViewports = 0x1000
}
[Flags]
public enum ImGuiButtonFlags
{
	None = 0,
	MouseButtonLeft = 1,
	MouseButtonRight = 2,
	MouseButtonMiddle = 4,
	MouseButtonMask = 7,
	MouseButtonDefault = 1
}
public enum ImGuiCol
{
	Text,
	TextDisabled,
	WindowBg,
	ChildBg,
	PopupBg,
	Border,
	BorderShadow,
	FrameBg,
	FrameBgHovered,
	FrameBgActive,
	TitleBg,
	TitleBgActive,
	TitleBgCollapsed,
	MenuBarBg,
	ScrollbarBg,
	ScrollbarGrab,
	ScrollbarGrabHovered,
	ScrollbarGrabActive,
	CheckMark,
	SliderGrab,
	SliderGrabActive,
	Button,
	ButtonHovered,
	ButtonActive,
	Header,
	HeaderHovered,
	HeaderActive,
	Separator,
	SeparatorHovered,
	SeparatorActive,
	ResizeGrip,
	ResizeGripHovered,
	ResizeGripActive,
	Tab,
	TabHovered,
	TabActive,
	TabUnfocused,
	TabUnfocusedActive,
	DockingPreview,
	DockingEmptyBg,
	PlotLines,
	PlotLinesHovered,
	PlotHistogram,
	PlotHistogramHovered,
	TableHeaderBg,
	TableBorderStrong,
	TableBorderLight,
	TableRowBg,
	TableRowBgAlt,
	TextSelectedBg,
	DragDropTarget,
	NavHighlight,
	NavWindowingHighlight,
	NavWindowingDimBg,
	ModalWindowDimBg,
	COUNT
}
[Flags]
public enum ImGuiColorEditFlags
{
	None = 0,
	NoAlpha = 2,
	NoPicker = 4,
	NoOptions = 8,
	NoSmallPreview = 0x10,
	NoInputs = 0x20,
	NoTooltip = 0x40,
	NoLabel = 0x80,
	NoSidePreview = 0x100,
	NoDragDrop = 0x200,
	NoBorder = 0x400,
	AlphaBar = 0x10000,
	AlphaPreview = 0x20000,
	AlphaPreviewHalf = 0x40000,
	HDR = 0x80000,
	DisplayRGB = 0x100000,
	DisplayHSV = 0x200000,
	DisplayHex = 0x400000,
	Uint8 = 0x800000,
	Float = 0x1000000,
	PickerHueBar = 0x2000000,
	PickerHueWheel = 0x4000000,
	InputRGB = 0x8000000,
	InputHSV = 0x10000000,
	DefaultOptions = 0xA900000,
	DisplayMask = 0x700000,
	DataTypeMask = 0x1800000,
	PickerMask = 0x6000000,
	InputMask = 0x18000000
}
[Flags]
public enum ImGuiComboFlags
{
	None = 0,
	PopupAlignLeft = 1,
	HeightSmall = 2,
	HeightRegular = 4,
	HeightLarge = 8,
	HeightLargest = 0x10,
	NoArrowButton = 0x20,
	NoPreview = 0x40,
	HeightMask = 0x1E
}
public enum ImGuiCond
{
	None = 0,
	Always = 1,
	Once = 2,
	FirstUseEver = 4,
	Appearing = 8
}
[Flags]
public enum ImGuiConfigFlags
{
	None = 0,
	NavEnableKeyboard = 1,
	NavEnableGamepad = 2,
	NavEnableSetMousePos = 4,
	NavNoCaptureKeyboard = 8,
	NoMouse = 0x10,
	NoMouseCursorChange = 0x20,
	DockingEnable = 0x40,
	ViewportsEnable = 0x400,
	DpiEnableScaleViewports = 0x4000,
	DpiEnableScaleFonts = 0x8000,
	IsSRGB = 0x100000,
	IsTouchScreen = 0x200000
}
public enum ImGuiDataType
{
	S8,
	U8,
	S16,
	U16,
	S32,
	U32,
	S64,
	U64,
	Float,
	Double,
	COUNT
}
public enum ImGuiDir
{
	None = -1,
	Left,
	Right,
	Up,
	Down,
	COUNT
}
[Flags]
public enum ImGuiDockNodeFlags
{
	None = 0,
	KeepAliveOnly = 1,
	NoDockingInCentralNode = 4,
	PassthruCentralNode = 8,
	NoSplit = 0x10,
	NoResize = 0x20,
	AutoHideTabBar = 0x40
}
[Flags]
public enum ImGuiDragDropFlags
{
	None = 0,
	SourceNoPreviewTooltip = 1,
	SourceNoDisableHover = 2,
	SourceNoHoldToOpenOthers = 4,
	SourceAllowNullID = 8,
	SourceExtern = 0x10,
	SourceAutoExpirePayload = 0x20,
	AcceptBeforeDelivery = 0x400,
	AcceptNoDrawDefaultRect = 0x800,
	AcceptNoPreviewTooltip = 0x1000,
	AcceptPeekOnly = 0xC00
}
[Flags]
public enum ImGuiFocusedFlags
{
	None = 0,
	ChildWindows = 1,
	RootWindow = 2,
	AnyWindow = 4,
	NoPopupHierarchy = 8,
	DockHierarchy = 0x10,
	RootAndChildWindows = 3
}
[Flags]
public enum ImGuiHoveredFlags
{
	None = 0,
	ChildWindows = 1,
	RootWindow = 2,
	AnyWindow = 4,
	NoPopupHierarchy = 8,
	DockHierarchy = 0x10,
	AllowWhenBlockedByPopup = 0x20,
	AllowWhenBlockedByActiveItem = 0x80,
	AllowWhenOverlapped = 0x100,
	AllowWhenDisabled = 0x200,
	NoNavOverride = 0x400,
	RectOnly = 0x1A0,
	RootAndChildWindows = 3,
	DelayNormal = 0x800,
	DelayShort = 0x1000,
	NoSharedDelay = 0x2000
}
public struct ImGuiInputTextCallbackData
{
	public ImGuiInputTextFlags EventFlag;

	public ImGuiInputTextFlags Flags;

	public unsafe void* UserData;

	public ushort EventChar;

	public ImGuiKey EventKey;

	public unsafe byte* Buf;

	public int BufTextLen;

	public int BufSize;

	public byte BufDirty;

	public int CursorPos;

	public int SelectionStart;

	public int SelectionEnd;
}
public struct ImGuiInputTextCallbackDataPtr
{
	public unsafe ImGuiInputTextCallbackData* NativePtr { get; }

	public unsafe ref ImGuiInputTextFlags EventFlag => ref Unsafe.AsRef<ImGuiInputTextFlags>(&NativePtr->EventFlag);

	public unsafe ref ImGuiInputTextFlags Flags => ref Unsafe.AsRef<ImGuiInputTextFlags>(&NativePtr->Flags);

	public unsafe IntPtr UserData
	{
		get
		{
			return (IntPtr)NativePtr->UserData;
		}
		set
		{
			NativePtr->UserData = (void*)value;
		}
	}

	public unsafe ref ushort EventChar => ref Unsafe.AsRef<ushort>(&NativePtr->EventChar);

	public unsafe ref ImGuiKey EventKey => ref Unsafe.AsRef<ImGuiKey>(&NativePtr->EventKey);

	public unsafe IntPtr Buf
	{
		get
		{
			return (IntPtr)NativePtr->Buf;
		}
		set
		{
			NativePtr->Buf = (byte*)(void*)value;
		}
	}

	public unsafe ref int BufTextLen => ref Unsafe.AsRef<int>(&NativePtr->BufTextLen);

	public unsafe ref int BufSize => ref Unsafe.AsRef<int>(&NativePtr->BufSize);

	public unsafe ref bool BufDirty => ref Unsafe.AsRef<bool>(&NativePtr->BufDirty);

	public unsafe ref int CursorPos => ref Unsafe.AsRef<int>(&NativePtr->CursorPos);

	public unsafe ref int SelectionStart => ref Unsafe.AsRef<int>(&NativePtr->SelectionStart);

	public unsafe ref int SelectionEnd => ref Unsafe.AsRef<int>(&NativePtr->SelectionEnd);

	public unsafe ImGuiInputTextCallbackDataPtr(ImGuiInputTextCallbackData* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImGuiInputTextCallbackDataPtr(IntPtr nativePtr)
	{
		NativePtr = (ImGuiInputTextCallbackData*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImGuiInputTextCallbackDataPtr(ImGuiInputTextCallbackData* nativePtr)
	{
		return new ImGuiInputTextCallbackDataPtr(nativePtr);
	}

	public unsafe static implicit operator ImGuiInputTextCallbackData*(ImGuiInputTextCallbackDataPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImGuiInputTextCallbackDataPtr(IntPtr nativePtr)
	{
		return new ImGuiInputTextCallbackDataPtr(nativePtr);
	}

	public unsafe void ClearSelection()
	{
		ImGuiNative.ImGuiInputTextCallbackData_ClearSelection(NativePtr);
	}

	public unsafe void DeleteChars(int pos, int bytes_count)
	{
		ImGuiNative.ImGuiInputTextCallbackData_DeleteChars(NativePtr, pos, bytes_count);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImGuiInputTextCallbackData_destroy(NativePtr);
	}

	public unsafe bool HasSelection()
	{
		return ImGuiNative.ImGuiInputTextCallbackData_HasSelection(NativePtr) != 0;
	}

	public unsafe void InsertChars(int pos, string text)
	{
		int num = 0;
		byte* ptr;
		if (text != null)
		{
			num = Encoding.UTF8.GetByteCount(text);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(text, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte* text_end = null;
		ImGuiNative.ImGuiInputTextCallbackData_InsertChars(NativePtr, pos, ptr, text_end);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe void SelectAll()
	{
		ImGuiNative.ImGuiInputTextCallbackData_SelectAll(NativePtr);
	}
}
[Flags]
public enum ImGuiInputTextFlags
{
	None = 0,
	CharsDecimal = 1,
	CharsHexadecimal = 2,
	CharsUppercase = 4,
	CharsNoBlank = 8,
	AutoSelectAll = 0x10,
	EnterReturnsTrue = 0x20,
	CallbackCompletion = 0x40,
	CallbackHistory = 0x80,
	CallbackAlways = 0x100,
	CallbackCharFilter = 0x200,
	AllowTabInput = 0x400,
	CtrlEnterForNewLine = 0x800,
	NoHorizontalScroll = 0x1000,
	AlwaysOverwrite = 0x2000,
	ReadOnly = 0x4000,
	Password = 0x8000,
	NoUndoRedo = 0x10000,
	CharsScientific = 0x20000,
	CallbackResize = 0x40000,
	CallbackEdit = 0x80000,
	EscapeClearsAll = 0x100000
}
public struct ImGuiIO
{
	public ImGuiConfigFlags ConfigFlags;

	public ImGuiBackendFlags BackendFlags;

	public Vector2 DisplaySize;

	public float DeltaTime;

	public float IniSavingRate;

	public unsafe byte* IniFilename;

	public unsafe byte* LogFilename;

	public float MouseDoubleClickTime;

	public float MouseDoubleClickMaxDist;

	public float MouseDragThreshold;

	public float KeyRepeatDelay;

	public float KeyRepeatRate;

	public float HoverDelayNormal;

	public float HoverDelayShort;

	public unsafe void* UserData;

	public unsafe ImFontAtlas* Fonts;

	public float FontGlobalScale;

	public byte FontAllowUserScaling;

	public unsafe ImFont* FontDefault;

	public Vector2 DisplayFramebufferScale;

	public byte ConfigDockingNoSplit;

	public byte ConfigDockingWithShift;

	public byte ConfigDockingAlwaysTabBar;

	public byte ConfigDockingTransparentPayload;

	public byte ConfigViewportsNoAutoMerge;

	public byte ConfigViewportsNoTaskBarIcon;

	public byte ConfigViewportsNoDecoration;

	public byte ConfigViewportsNoDefaultParent;

	public byte MouseDrawCursor;

	public byte ConfigMacOSXBehaviors;

	public byte ConfigInputTrickleEventQueue;

	public byte ConfigInputTextCursorBlink;

	public byte ConfigInputTextEnterKeepActive;

	public byte ConfigDragClickToInputText;

	public byte ConfigWindowsResizeFromEdges;

	public byte ConfigWindowsMoveFromTitleBarOnly;

	public float ConfigMemoryCompactTimer;

	public unsafe byte* BackendPlatformName;

	public unsafe byte* BackendRendererName;

	public unsafe void* BackendPlatformUserData;

	public unsafe void* BackendRendererUserData;

	public unsafe void* BackendLanguageUserData;

	public IntPtr GetClipboardTextFn;

	public IntPtr SetClipboardTextFn;

	public unsafe void* ClipboardUserData;

	public IntPtr SetPlatformImeDataFn;

	public unsafe void* _UnusedPadding;

	public byte WantCaptureMouse;

	public byte WantCaptureKeyboard;

	public byte WantTextInput;

	public byte WantSetMousePos;

	public byte WantSaveIniSettings;

	public byte NavActive;

	public byte NavVisible;

	public float Framerate;

	public int MetricsRenderVertices;

	public int MetricsRenderIndices;

	public int MetricsRenderWindows;

	public int MetricsActiveWindows;

	public int MetricsActiveAllocations;

	public Vector2 MouseDelta;

	public unsafe fixed int KeyMap[652];

	public unsafe fixed byte KeysDown[652];

	public unsafe fixed float NavInputs[16];

	public Vector2 MousePos;

	public unsafe fixed byte MouseDown[5];

	public float MouseWheel;

	public float MouseWheelH;

	public uint MouseHoveredViewport;

	public byte KeyCtrl;

	public byte KeyShift;

	public byte KeyAlt;

	public byte KeySuper;

	public ImGuiKey KeyMods;

	public ImGuiKeyData KeysData_0;

	public ImGuiKeyData KeysData_1;

	public ImGuiKeyData KeysData_2;

	public ImGuiKeyData KeysData_3;

	public ImGuiKeyData KeysData_4;

	public ImGuiKeyData KeysData_5;

	public ImGuiKeyData KeysData_6;

	public ImGuiKeyData KeysData_7;

	public ImGuiKeyData KeysData_8;

	public ImGuiKeyData KeysData_9;

	public ImGuiKeyData KeysData_10;

	public ImGuiKeyData KeysData_11;

	public ImGuiKeyData KeysData_12;

	public ImGuiKeyData KeysData_13;

	public ImGuiKeyData KeysData_14;

	public ImGuiKeyData KeysData_15;

	public ImGuiKeyData KeysData_16;

	public ImGuiKeyData KeysData_17;

	public ImGuiKeyData KeysData_18;

	public ImGuiKeyData KeysData_19;

	public ImGuiKeyData KeysData_20;

	public ImGuiKeyData KeysData_21;

	public ImGuiKeyData KeysData_22;

	public ImGuiKeyData KeysData_23;

	public ImGuiKeyData KeysData_24;

	public ImGuiKeyData KeysData_25;

	public ImGuiKeyData KeysData_26;

	public ImGuiKeyData KeysData_27;

	public ImGuiKeyData KeysData_28;

	public ImGuiKeyData KeysData_29;

	public ImGuiKeyData KeysData_30;

	public ImGuiKeyData KeysData_31;

	public ImGuiKeyData KeysData_32;

	public ImGuiKeyData KeysData_33;

	public ImGuiKeyData KeysData_34;

	public ImGuiKeyData KeysData_35;

	public ImGuiKeyData KeysData_36;

	public ImGuiKeyData KeysData_37;

	public ImGuiKeyData KeysData_38;

	public ImGuiKeyData KeysData_39;

	public ImGuiKeyData KeysData_40;

	public ImGuiKeyData KeysData_41;

	public ImGuiKeyData KeysData_42;

	public ImGuiKeyData KeysData_43;

	public ImGuiKeyData KeysData_44;

	public ImGuiKeyData KeysData_45;

	public ImGuiKeyData KeysData_46;

	public ImGuiKeyData KeysData_47;

	public ImGuiKeyData KeysData_48;

	public ImGuiKeyData KeysData_49;

	public ImGuiKeyData KeysData_50;

	public ImGuiKeyData KeysData_51;

	public ImGuiKeyData KeysData_52;

	public ImGuiKeyData KeysData_53;

	public ImGuiKeyData KeysData_54;

	public ImGuiKeyData KeysData_55;

	public ImGuiKeyData KeysData_56;

	public ImGuiKeyData KeysData_57;

	public ImGuiKeyData KeysData_58;

	public ImGuiKeyData KeysData_59;

	public ImGuiKeyData KeysData_60;

	public ImGuiKeyData KeysData_61;

	public ImGuiKeyData KeysData_62;

	public ImGuiKeyData KeysData_63;

	public ImGuiKeyData KeysData_64;

	public ImGuiKeyData KeysData_65;

	public ImGuiKeyData KeysData_66;

	public ImGuiKeyData KeysData_67;

	public ImGuiKeyData KeysData_68;

	public ImGuiKeyData KeysData_69;

	public ImGuiKeyData KeysData_70;

	public ImGuiKeyData KeysData_71;

	public ImGuiKeyData KeysData_72;

	public ImGuiKeyData KeysData_73;

	public ImGuiKeyData KeysData_74;

	public ImGuiKeyData KeysData_75;

	public ImGuiKeyData KeysData_76;

	public ImGuiKeyData KeysData_77;

	public ImGuiKeyData KeysData_78;

	public ImGuiKeyData KeysData_79;

	public ImGuiKeyData KeysData_80;

	public ImGuiKeyData KeysData_81;

	public ImGuiKeyData KeysData_82;

	public ImGuiKeyData KeysData_83;

	public ImGuiKeyData KeysData_84;

	public ImGuiKeyData KeysData_85;

	public ImGuiKeyData KeysData_86;

	public ImGuiKeyData KeysData_87;

	public ImGuiKeyData KeysData_88;

	public ImGuiKeyData KeysData_89;

	public ImGuiKeyData KeysData_90;

	public ImGuiKeyData KeysData_91;

	public ImGuiKeyData KeysData_92;

	public ImGuiKeyData KeysData_93;

	public ImGuiKeyData KeysData_94;

	public ImGuiKeyData KeysData_95;

	public ImGuiKeyData KeysData_96;

	public ImGuiKeyData KeysData_97;

	public ImGuiKeyData KeysData_98;

	public ImGuiKeyData KeysData_99;

	public ImGuiKeyData KeysData_100;

	public ImGuiKeyData KeysData_101;

	public ImGuiKeyData KeysData_102;

	public ImGuiKeyData KeysData_103;

	public ImGuiKeyData KeysData_104;

	public ImGuiKeyData KeysData_105;

	public ImGuiKeyData KeysData_106;

	public ImGuiKeyData KeysData_107;

	public ImGuiKeyData KeysData_108;

	public ImGuiKeyData KeysData_109;

	public ImGuiKeyData KeysData_110;

	public ImGuiKeyData KeysData_111;

	public ImGuiKeyData KeysData_112;

	public ImGuiKeyData KeysData_113;

	public ImGuiKeyData KeysData_114;

	public ImGuiKeyData KeysData_115;

	public ImGuiKeyData KeysData_116;

	public ImGuiKeyData KeysData_117;

	public ImGuiKeyData KeysData_118;

	public ImGuiKeyData KeysData_119;

	public ImGuiKeyData KeysData_120;

	public ImGuiKeyData KeysData_121;

	public ImGuiKeyData KeysData_122;

	public ImGuiKeyData KeysData_123;

	public ImGuiKeyData KeysData_124;

	public ImGuiKeyData KeysData_125;

	public ImGuiKeyData KeysData_126;

	public ImGuiKeyData KeysData_127;

	public ImGuiKeyData KeysData_128;

	public ImGuiKeyData KeysData_129;

	public ImGuiKeyData KeysData_130;

	public ImGuiKeyData KeysData_131;

	public ImGuiKeyData KeysData_132;

	public ImGuiKeyData KeysData_133;

	public ImGuiKeyData KeysData_134;

	public ImGuiKeyData KeysData_135;

	public ImGuiKeyData KeysData_136;

	public ImGuiKeyData KeysData_137;

	public ImGuiKeyData KeysData_138;

	public ImGuiKeyData KeysData_139;

	public ImGuiKeyData KeysData_140;

	public ImGuiKeyData KeysData_141;

	public ImGuiKeyData KeysData_142;

	public ImGuiKeyData KeysData_143;

	public ImGuiKeyData KeysData_144;

	public ImGuiKeyData KeysData_145;

	public ImGuiKeyData KeysData_146;

	public ImGuiKeyData KeysData_147;

	public ImGuiKeyData KeysData_148;

	public ImGuiKeyData KeysData_149;

	public ImGuiKeyData KeysData_150;

	public ImGuiKeyData KeysData_151;

	public ImGuiKeyData KeysData_152;

	public ImGuiKeyData KeysData_153;

	public ImGuiKeyData KeysData_154;

	public ImGuiKeyData KeysData_155;

	public ImGuiKeyData KeysData_156;

	public ImGuiKeyData KeysData_157;

	public ImGuiKeyData KeysData_158;

	public ImGuiKeyData KeysData_159;

	public ImGuiKeyData KeysData_160;

	public ImGuiKeyData KeysData_161;

	public ImGuiKeyData KeysData_162;

	public ImGuiKeyData KeysData_163;

	public ImGuiKeyData KeysData_164;

	public ImGuiKeyData KeysData_165;

	public ImGuiKeyData KeysData_166;

	public ImGuiKeyData KeysData_167;

	public ImGuiKeyData KeysData_168;

	public ImGuiKeyData KeysData_169;

	public ImGuiKeyData KeysData_170;

	public ImGuiKeyData KeysData_171;

	public ImGuiKeyData KeysData_172;

	public ImGuiKeyData KeysData_173;

	public ImGuiKeyData KeysData_174;

	public ImGuiKeyData KeysData_175;

	public ImGuiKeyData KeysData_176;

	public ImGuiKeyData KeysData_177;

	public ImGuiKeyData KeysData_178;

	public ImGuiKeyData KeysData_179;

	public ImGuiKeyData KeysData_180;

	public ImGuiKeyData KeysData_181;

	public ImGuiKeyData KeysData_182;

	public ImGuiKeyData KeysData_183;

	public ImGuiKeyData KeysData_184;

	public ImGuiKeyData KeysData_185;

	public ImGuiKeyData KeysData_186;

	public ImGuiKeyData KeysData_187;

	public ImGuiKeyData KeysData_188;

	public ImGuiKeyData KeysData_189;

	public ImGuiKeyData KeysData_190;

	public ImGuiKeyData KeysData_191;

	public ImGuiKeyData KeysData_192;

	public ImGuiKeyData KeysData_193;

	public ImGuiKeyData KeysData_194;

	public ImGuiKeyData KeysData_195;

	public ImGuiKeyData KeysData_196;

	public ImGuiKeyData KeysData_197;

	public ImGuiKeyData KeysData_198;

	public ImGuiKeyData KeysData_199;

	public ImGuiKeyData KeysData_200;

	public ImGuiKeyData KeysData_201;

	public ImGuiKeyData KeysData_202;

	public ImGuiKeyData KeysData_203;

	public ImGuiKeyData KeysData_204;

	public ImGuiKeyData KeysData_205;

	public ImGuiKeyData KeysData_206;

	public ImGuiKeyData KeysData_207;

	public ImGuiKeyData KeysData_208;

	public ImGuiKeyData KeysData_209;

	public ImGuiKeyData KeysData_210;

	public ImGuiKeyData KeysData_211;

	public ImGuiKeyData KeysData_212;

	public ImGuiKeyData KeysData_213;

	public ImGuiKeyData KeysData_214;

	public ImGuiKeyData KeysData_215;

	public ImGuiKeyData KeysData_216;

	public ImGuiKeyData KeysData_217;

	public ImGuiKeyData KeysData_218;

	public ImGuiKeyData KeysData_219;

	public ImGuiKeyData KeysData_220;

	public ImGuiKeyData KeysData_221;

	public ImGuiKeyData KeysData_222;

	public ImGuiKeyData KeysData_223;

	public ImGuiKeyData KeysData_224;

	public ImGuiKeyData KeysData_225;

	public ImGuiKeyData KeysData_226;

	public ImGuiKeyData KeysData_227;

	public ImGuiKeyData KeysData_228;

	public ImGuiKeyData KeysData_229;

	public ImGuiKeyData KeysData_230;

	public ImGuiKeyData KeysData_231;

	public ImGuiKeyData KeysData_232;

	public ImGuiKeyData KeysData_233;

	public ImGuiKeyData KeysData_234;

	public ImGuiKeyData KeysData_235;

	public ImGuiKeyData KeysData_236;

	public ImGuiKeyData KeysData_237;

	public ImGuiKeyData KeysData_238;

	public ImGuiKeyData KeysData_239;

	public ImGuiKeyData KeysData_240;

	public ImGuiKeyData KeysData_241;

	public ImGuiKeyData KeysData_242;

	public ImGuiKeyData KeysData_243;

	public ImGuiKeyData KeysData_244;

	public ImGuiKeyData KeysData_245;

	public ImGuiKeyData KeysData_246;

	public ImGuiKeyData KeysData_247;

	public ImGuiKeyData KeysData_248;

	public ImGuiKeyData KeysData_249;

	public ImGuiKeyData KeysData_250;

	public ImGuiKeyData KeysData_251;

	public ImGuiKeyData KeysData_252;

	public ImGuiKeyData KeysData_253;

	public ImGuiKeyData KeysData_254;

	public ImGuiKeyData KeysData_255;

	public ImGuiKeyData KeysData_256;

	public ImGuiKeyData KeysData_257;

	public ImGuiKeyData KeysData_258;

	public ImGuiKeyData KeysData_259;

	public ImGuiKeyData KeysData_260;

	public ImGuiKeyData KeysData_261;

	public ImGuiKeyData KeysData_262;

	public ImGuiKeyData KeysData_263;

	public ImGuiKeyData KeysData_264;

	public ImGuiKeyData KeysData_265;

	public ImGuiKeyData KeysData_266;

	public ImGuiKeyData KeysData_267;

	public ImGuiKeyData KeysData_268;

	public ImGuiKeyData KeysData_269;

	public ImGuiKeyData KeysData_270;

	public ImGuiKeyData KeysData_271;

	public ImGuiKeyData KeysData_272;

	public ImGuiKeyData KeysData_273;

	public ImGuiKeyData KeysData_274;

	public ImGuiKeyData KeysData_275;

	public ImGuiKeyData KeysData_276;

	public ImGuiKeyData KeysData_277;

	public ImGuiKeyData KeysData_278;

	public ImGuiKeyData KeysData_279;

	public ImGuiKeyData KeysData_280;

	public ImGuiKeyData KeysData_281;

	public ImGuiKeyData KeysData_282;

	public ImGuiKeyData KeysData_283;

	public ImGuiKeyData KeysData_284;

	public ImGuiKeyData KeysData_285;

	public ImGuiKeyData KeysData_286;

	public ImGuiKeyData KeysData_287;

	public ImGuiKeyData KeysData_288;

	public ImGuiKeyData KeysData_289;

	public ImGuiKeyData KeysData_290;

	public ImGuiKeyData KeysData_291;

	public ImGuiKeyData KeysData_292;

	public ImGuiKeyData KeysData_293;

	public ImGuiKeyData KeysData_294;

	public ImGuiKeyData KeysData_295;

	public ImGuiKeyData KeysData_296;

	public ImGuiKeyData KeysData_297;

	public ImGuiKeyData KeysData_298;

	public ImGuiKeyData KeysData_299;

	public ImGuiKeyData KeysData_300;

	public ImGuiKeyData KeysData_301;

	public ImGuiKeyData KeysData_302;

	public ImGuiKeyData KeysData_303;

	public ImGuiKeyData KeysData_304;

	public ImGuiKeyData KeysData_305;

	public ImGuiKeyData KeysData_306;

	public ImGuiKeyData KeysData_307;

	public ImGuiKeyData KeysData_308;

	public ImGuiKeyData KeysData_309;

	public ImGuiKeyData KeysData_310;

	public ImGuiKeyData KeysData_311;

	public ImGuiKeyData KeysData_312;

	public ImGuiKeyData KeysData_313;

	public ImGuiKeyData KeysData_314;

	public ImGuiKeyData KeysData_315;

	public ImGuiKeyData KeysData_316;

	public ImGuiKeyData KeysData_317;

	public ImGuiKeyData KeysData_318;

	public ImGuiKeyData KeysData_319;

	public ImGuiKeyData KeysData_320;

	public ImGuiKeyData KeysData_321;

	public ImGuiKeyData KeysData_322;

	public ImGuiKeyData KeysData_323;

	public ImGuiKeyData KeysData_324;

	public ImGuiKeyData KeysData_325;

	public ImGuiKeyData KeysData_326;

	public ImGuiKeyData KeysData_327;

	public ImGuiKeyData KeysData_328;

	public ImGuiKeyData KeysData_329;

	public ImGuiKeyData KeysData_330;

	public ImGuiKeyData KeysData_331;

	public ImGuiKeyData KeysData_332;

	public ImGuiKeyData KeysData_333;

	public ImGuiKeyData KeysData_334;

	public ImGuiKeyData KeysData_335;

	public ImGuiKeyData KeysData_336;

	public ImGuiKeyData KeysData_337;

	public ImGuiKeyData KeysData_338;

	public ImGuiKeyData KeysData_339;

	public ImGuiKeyData KeysData_340;

	public ImGuiKeyData KeysData_341;

	public ImGuiKeyData KeysData_342;

	public ImGuiKeyData KeysData_343;

	public ImGuiKeyData KeysData_344;

	public ImGuiKeyData KeysData_345;

	public ImGuiKeyData KeysData_346;

	public ImGuiKeyData KeysData_347;

	public ImGuiKeyData KeysData_348;

	public ImGuiKeyData KeysData_349;

	public ImGuiKeyData KeysData_350;

	public ImGuiKeyData KeysData_351;

	public ImGuiKeyData KeysData_352;

	public ImGuiKeyData KeysData_353;

	public ImGuiKeyData KeysData_354;

	public ImGuiKeyData KeysData_355;

	public ImGuiKeyData KeysData_356;

	public ImGuiKeyData KeysData_357;

	public ImGuiKeyData KeysData_358;

	public ImGuiKeyData KeysData_359;

	public ImGuiKeyData KeysData_360;

	public ImGuiKeyData KeysData_361;

	public ImGuiKeyData KeysData_362;

	public ImGuiKeyData KeysData_363;

	public ImGuiKeyData KeysData_364;

	public ImGuiKeyData KeysData_365;

	public ImGuiKeyData KeysData_366;

	public ImGuiKeyData KeysData_367;

	public ImGuiKeyData KeysData_368;

	public ImGuiKeyData KeysData_369;

	public ImGuiKeyData KeysData_370;

	public ImGuiKeyData KeysData_371;

	public ImGuiKeyData KeysData_372;

	public ImGuiKeyData KeysData_373;

	public ImGuiKeyData KeysData_374;

	public ImGuiKeyData KeysData_375;

	public ImGuiKeyData KeysData_376;

	public ImGuiKeyData KeysData_377;

	public ImGuiKeyData KeysData_378;

	public ImGuiKeyData KeysData_379;

	public ImGuiKeyData KeysData_380;

	public ImGuiKeyData KeysData_381;

	public ImGuiKeyData KeysData_382;

	public ImGuiKeyData KeysData_383;

	public ImGuiKeyData KeysData_384;

	public ImGuiKeyData KeysData_385;

	public ImGuiKeyData KeysData_386;

	public ImGuiKeyData KeysData_387;

	public ImGuiKeyData KeysData_388;

	public ImGuiKeyData KeysData_389;

	public ImGuiKeyData KeysData_390;

	public ImGuiKeyData KeysData_391;

	public ImGuiKeyData KeysData_392;

	public ImGuiKeyData KeysData_393;

	public ImGuiKeyData KeysData_394;

	public ImGuiKeyData KeysData_395;

	public ImGuiKeyData KeysData_396;

	public ImGuiKeyData KeysData_397;

	public ImGuiKeyData KeysData_398;

	public ImGuiKeyData KeysData_399;

	public ImGuiKeyData KeysData_400;

	public ImGuiKeyData KeysData_401;

	public ImGuiKeyData KeysData_402;

	public ImGuiKeyData KeysData_403;

	public ImGuiKeyData KeysData_404;

	public ImGuiKeyData KeysData_405;

	public ImGuiKeyData KeysData_406;

	public ImGuiKeyData KeysData_407;

	public ImGuiKeyData KeysData_408;

	public ImGuiKeyData KeysData_409;

	public ImGuiKeyData KeysData_410;

	public ImGuiKeyData KeysData_411;

	public ImGuiKeyData KeysData_412;

	public ImGuiKeyData KeysData_413;

	public ImGuiKeyData KeysData_414;

	public ImGuiKeyData KeysData_415;

	public ImGuiKeyData KeysData_416;

	public ImGuiKeyData KeysData_417;

	public ImGuiKeyData KeysData_418;

	public ImGuiKeyData KeysData_419;

	public ImGuiKeyData KeysData_420;

	public ImGuiKeyData KeysData_421;

	public ImGuiKeyData KeysData_422;

	public ImGuiKeyData KeysData_423;

	public ImGuiKeyData KeysData_424;

	public ImGuiKeyData KeysData_425;

	public ImGuiKeyData KeysData_426;

	public ImGuiKeyData KeysData_427;

	public ImGuiKeyData KeysData_428;

	public ImGuiKeyData KeysData_429;

	public ImGuiKeyData KeysData_430;

	public ImGuiKeyData KeysData_431;

	public ImGuiKeyData KeysData_432;

	public ImGuiKeyData KeysData_433;

	public ImGuiKeyData KeysData_434;

	public ImGuiKeyData KeysData_435;

	public ImGuiKeyData KeysData_436;

	public ImGuiKeyData KeysData_437;

	public ImGuiKeyData KeysData_438;

	public ImGuiKeyData KeysData_439;

	public ImGuiKeyData KeysData_440;

	public ImGuiKeyData KeysData_441;

	public ImGuiKeyData KeysData_442;

	public ImGuiKeyData KeysData_443;

	public ImGuiKeyData KeysData_444;

	public ImGuiKeyData KeysData_445;

	public ImGuiKeyData KeysData_446;

	public ImGuiKeyData KeysData_447;

	public ImGuiKeyData KeysData_448;

	public ImGuiKeyData KeysData_449;

	public ImGuiKeyData KeysData_450;

	public ImGuiKeyData KeysData_451;

	public ImGuiKeyData KeysData_452;

	public ImGuiKeyData KeysData_453;

	public ImGuiKeyData KeysData_454;

	public ImGuiKeyData KeysData_455;

	public ImGuiKeyData KeysData_456;

	public ImGuiKeyData KeysData_457;

	public ImGuiKeyData KeysData_458;

	public ImGuiKeyData KeysData_459;

	public ImGuiKeyData KeysData_460;

	public ImGuiKeyData KeysData_461;

	public ImGuiKeyData KeysData_462;

	public ImGuiKeyData KeysData_463;

	public ImGuiKeyData KeysData_464;

	public ImGuiKeyData KeysData_465;

	public ImGuiKeyData KeysData_466;

	public ImGuiKeyData KeysData_467;

	public ImGuiKeyData KeysData_468;

	public ImGuiKeyData KeysData_469;

	public ImGuiKeyData KeysData_470;

	public ImGuiKeyData KeysData_471;

	public ImGuiKeyData KeysData_472;

	public ImGuiKeyData KeysData_473;

	public ImGuiKeyData KeysData_474;

	public ImGuiKeyData KeysData_475;

	public ImGuiKeyData KeysData_476;

	public ImGuiKeyData KeysData_477;

	public ImGuiKeyData KeysData_478;

	public ImGuiKeyData KeysData_479;

	public ImGuiKeyData KeysData_480;

	public ImGuiKeyData KeysData_481;

	public ImGuiKeyData KeysData_482;

	public ImGuiKeyData KeysData_483;

	public ImGuiKeyData KeysData_484;

	public ImGuiKeyData KeysData_485;

	public ImGuiKeyData KeysData_486;

	public ImGuiKeyData KeysData_487;

	public ImGuiKeyData KeysData_488;

	public ImGuiKeyData KeysData_489;

	public ImGuiKeyData KeysData_490;

	public ImGuiKeyData KeysData_491;

	public ImGuiKeyData KeysData_492;

	public ImGuiKeyData KeysData_493;

	public ImGuiKeyData KeysData_494;

	public ImGuiKeyData KeysData_495;

	public ImGuiKeyData KeysData_496;

	public ImGuiKeyData KeysData_497;

	public ImGuiKeyData KeysData_498;

	public ImGuiKeyData KeysData_499;

	public ImGuiKeyData KeysData_500;

	public ImGuiKeyData KeysData_501;

	public ImGuiKeyData KeysData_502;

	public ImGuiKeyData KeysData_503;

	public ImGuiKeyData KeysData_504;

	public ImGuiKeyData KeysData_505;

	public ImGuiKeyData KeysData_506;

	public ImGuiKeyData KeysData_507;

	public ImGuiKeyData KeysData_508;

	public ImGuiKeyData KeysData_509;

	public ImGuiKeyData KeysData_510;

	public ImGuiKeyData KeysData_511;

	public ImGuiKeyData KeysData_512;

	public ImGuiKeyData KeysData_513;

	public ImGuiKeyData KeysData_514;

	public ImGuiKeyData KeysData_515;

	public ImGuiKeyData KeysData_516;

	public ImGuiKeyData KeysData_517;

	public ImGuiKeyData KeysData_518;

	public ImGuiKeyData KeysData_519;

	public ImGuiKeyData KeysData_520;

	public ImGuiKeyData KeysData_521;

	public ImGuiKeyData KeysData_522;

	public ImGuiKeyData KeysData_523;

	public ImGuiKeyData KeysData_524;

	public ImGuiKeyData KeysData_525;

	public ImGuiKeyData KeysData_526;

	public ImGuiKeyData KeysData_527;

	public ImGuiKeyData KeysData_528;

	public ImGuiKeyData KeysData_529;

	public ImGuiKeyData KeysData_530;

	public ImGuiKeyData KeysData_531;

	public ImGuiKeyData KeysData_532;

	public ImGuiKeyData KeysData_533;

	public ImGuiKeyData KeysData_534;

	public ImGuiKeyData KeysData_535;

	public ImGuiKeyData KeysData_536;

	public ImGuiKeyData KeysData_537;

	public ImGuiKeyData KeysData_538;

	public ImGuiKeyData KeysData_539;

	public ImGuiKeyData KeysData_540;

	public ImGuiKeyData KeysData_541;

	public ImGuiKeyData KeysData_542;

	public ImGuiKeyData KeysData_543;

	public ImGuiKeyData KeysData_544;

	public ImGuiKeyData KeysData_545;

	public ImGuiKeyData KeysData_546;

	public ImGuiKeyData KeysData_547;

	public ImGuiKeyData KeysData_548;

	public ImGuiKeyData KeysData_549;

	public ImGuiKeyData KeysData_550;

	public ImGuiKeyData KeysData_551;

	public ImGuiKeyData KeysData_552;

	public ImGuiKeyData KeysData_553;

	public ImGuiKeyData KeysData_554;

	public ImGuiKeyData KeysData_555;

	public ImGuiKeyData KeysData_556;

	public ImGuiKeyData KeysData_557;

	public ImGuiKeyData KeysData_558;

	public ImGuiKeyData KeysData_559;

	public ImGuiKeyData KeysData_560;

	public ImGuiKeyData KeysData_561;

	public ImGuiKeyData KeysData_562;

	public ImGuiKeyData KeysData_563;

	public ImGuiKeyData KeysData_564;

	public ImGuiKeyData KeysData_565;

	public ImGuiKeyData KeysData_566;

	public ImGuiKeyData KeysData_567;

	public ImGuiKeyData KeysData_568;

	public ImGuiKeyData KeysData_569;

	public ImGuiKeyData KeysData_570;

	public ImGuiKeyData KeysData_571;

	public ImGuiKeyData KeysData_572;

	public ImGuiKeyData KeysData_573;

	public ImGuiKeyData KeysData_574;

	public ImGuiKeyData KeysData_575;

	public ImGuiKeyData KeysData_576;

	public ImGuiKeyData KeysData_577;

	public ImGuiKeyData KeysData_578;

	public ImGuiKeyData KeysData_579;

	public ImGuiKeyData KeysData_580;

	public ImGuiKeyData KeysData_581;

	public ImGuiKeyData KeysData_582;

	public ImGuiKeyData KeysData_583;

	public ImGuiKeyData KeysData_584;

	public ImGuiKeyData KeysData_585;

	public ImGuiKeyData KeysData_586;

	public ImGuiKeyData KeysData_587;

	public ImGuiKeyData KeysData_588;

	public ImGuiKeyData KeysData_589;

	public ImGuiKeyData KeysData_590;

	public ImGuiKeyData KeysData_591;

	public ImGuiKeyData KeysData_592;

	public ImGuiKeyData KeysData_593;

	public ImGuiKeyData KeysData_594;

	public ImGuiKeyData KeysData_595;

	public ImGuiKeyData KeysData_596;

	public ImGuiKeyData KeysData_597;

	public ImGuiKeyData KeysData_598;

	public ImGuiKeyData KeysData_599;

	public ImGuiKeyData KeysData_600;

	public ImGuiKeyData KeysData_601;

	public ImGuiKeyData KeysData_602;

	public ImGuiKeyData KeysData_603;

	public ImGuiKeyData KeysData_604;

	public ImGuiKeyData KeysData_605;

	public ImGuiKeyData KeysData_606;

	public ImGuiKeyData KeysData_607;

	public ImGuiKeyData KeysData_608;

	public ImGuiKeyData KeysData_609;

	public ImGuiKeyData KeysData_610;

	public ImGuiKeyData KeysData_611;

	public ImGuiKeyData KeysData_612;

	public ImGuiKeyData KeysData_613;

	public ImGuiKeyData KeysData_614;

	public ImGuiKeyData KeysData_615;

	public ImGuiKeyData KeysData_616;

	public ImGuiKeyData KeysData_617;

	public ImGuiKeyData KeysData_618;

	public ImGuiKeyData KeysData_619;

	public ImGuiKeyData KeysData_620;

	public ImGuiKeyData KeysData_621;

	public ImGuiKeyData KeysData_622;

	public ImGuiKeyData KeysData_623;

	public ImGuiKeyData KeysData_624;

	public ImGuiKeyData KeysData_625;

	public ImGuiKeyData KeysData_626;

	public ImGuiKeyData KeysData_627;

	public ImGuiKeyData KeysData_628;

	public ImGuiKeyData KeysData_629;

	public ImGuiKeyData KeysData_630;

	public ImGuiKeyData KeysData_631;

	public ImGuiKeyData KeysData_632;

	public ImGuiKeyData KeysData_633;

	public ImGuiKeyData KeysData_634;

	public ImGuiKeyData KeysData_635;

	public ImGuiKeyData KeysData_636;

	public ImGuiKeyData KeysData_637;

	public ImGuiKeyData KeysData_638;

	public ImGuiKeyData KeysData_639;

	public ImGuiKeyData KeysData_640;

	public ImGuiKeyData KeysData_641;

	public ImGuiKeyData KeysData_642;

	public ImGuiKeyData KeysData_643;

	public ImGuiKeyData KeysData_644;

	public ImGuiKeyData KeysData_645;

	public ImGuiKeyData KeysData_646;

	public ImGuiKeyData KeysData_647;

	public ImGuiKeyData KeysData_648;

	public ImGuiKeyData KeysData_649;

	public ImGuiKeyData KeysData_650;

	public ImGuiKeyData KeysData_651;

	public byte WantCaptureMouseUnlessPopupClose;

	public Vector2 MousePosPrev;

	public Vector2 MouseClickedPos_0;

	public Vector2 MouseClickedPos_1;

	public Vector2 MouseClickedPos_2;

	public Vector2 MouseClickedPos_3;

	public Vector2 MouseClickedPos_4;

	public unsafe fixed double MouseClickedTime[5];

	public unsafe fixed byte MouseClicked[5];

	public unsafe fixed byte MouseDoubleClicked[5];

	public unsafe fixed ushort MouseClickedCount[5];

	public unsafe fixed ushort MouseClickedLastCount[5];

	public unsafe fixed byte MouseReleased[5];

	public unsafe fixed byte MouseDownOwned[5];

	public unsafe fixed byte MouseDownOwnedUnlessPopupClose[5];

	public unsafe fixed float MouseDownDuration[5];

	public unsafe fixed float MouseDownDurationPrev[5];

	public Vector2 MouseDragMaxDistanceAbs_0;

	public Vector2 MouseDragMaxDistanceAbs_1;

	public Vector2 MouseDragMaxDistanceAbs_2;

	public Vector2 MouseDragMaxDistanceAbs_3;

	public Vector2 MouseDragMaxDistanceAbs_4;

	public unsafe fixed float MouseDragMaxDistanceSqr[5];

	public float PenPressure;

	public byte AppFocusLost;

	public byte AppAcceptingEvents;

	public sbyte BackendUsingLegacyKeyArrays;

	public byte BackendUsingLegacyNavInputArray;

	public ushort InputQueueSurrogate;

	public ImVector InputQueueCharacters;
}
public struct ImGuiIOPtr
{
	public unsafe ImGuiIO* NativePtr { get; }

	public unsafe ref ImGuiConfigFlags ConfigFlags => ref Unsafe.AsRef<ImGuiConfigFlags>(&NativePtr->ConfigFlags);

	public unsafe ref ImGuiBackendFlags BackendFlags => ref Unsafe.AsRef<ImGuiBackendFlags>(&NativePtr->BackendFlags);

	public unsafe ref Vector2 DisplaySize => ref Unsafe.AsRef<Vector2>(&NativePtr->DisplaySize);

	public unsafe ref float DeltaTime => ref Unsafe.AsRef<float>(&NativePtr->DeltaTime);

	public unsafe ref float IniSavingRate => ref Unsafe.AsRef<float>(&NativePtr->IniSavingRate);

	public unsafe NullTerminatedString IniFilename => new NullTerminatedString(NativePtr->IniFilename);

	public unsafe NullTerminatedString LogFilename => new NullTerminatedString(NativePtr->LogFilename);

	public unsafe ref float MouseDoubleClickTime => ref Unsafe.AsRef<float>(&NativePtr->MouseDoubleClickTime);

	public unsafe ref float MouseDoubleClickMaxDist => ref Unsafe.AsRef<float>(&NativePtr->MouseDoubleClickMaxDist);

	public unsafe ref float MouseDragThreshold => ref Unsafe.AsRef<float>(&NativePtr->MouseDragThreshold);

	public unsafe ref float KeyRepeatDelay => ref Unsafe.AsRef<float>(&NativePtr->KeyRepeatDelay);

	public unsafe ref float KeyRepeatRate => ref Unsafe.AsRef<float>(&NativePtr->KeyRepeatRate);

	public unsafe ref float HoverDelayNormal => ref Unsafe.AsRef<float>(&NativePtr->HoverDelayNormal);

	public unsafe ref float HoverDelayShort => ref Unsafe.AsRef<float>(&NativePtr->HoverDelayShort);

	public unsafe IntPtr UserData
	{
		get
		{
			return (IntPtr)NativePtr->UserData;
		}
		set
		{
			NativePtr->UserData = (void*)value;
		}
	}

	public unsafe ImFontAtlasPtr Fonts => new ImFontAtlasPtr(NativePtr->Fonts);

	public unsafe ref float FontGlobalScale => ref Unsafe.AsRef<float>(&NativePtr->FontGlobalScale);

	public unsafe ref bool FontAllowUserScaling => ref Unsafe.AsRef<bool>(&NativePtr->FontAllowUserScaling);

	public unsafe ImFontPtr FontDefault => new ImFontPtr(NativePtr->FontDefault);

	public unsafe ref Vector2 DisplayFramebufferScale => ref Unsafe.AsRef<Vector2>(&NativePtr->DisplayFramebufferScale);

	public unsafe ref bool ConfigDockingNoSplit => ref Unsafe.AsRef<bool>(&NativePtr->ConfigDockingNoSplit);

	public unsafe ref bool ConfigDockingWithShift => ref Unsafe.AsRef<bool>(&NativePtr->ConfigDockingWithShift);

	public unsafe ref bool ConfigDockingAlwaysTabBar => ref Unsafe.AsRef<bool>(&NativePtr->ConfigDockingAlwaysTabBar);

	public unsafe ref bool ConfigDockingTransparentPayload => ref Unsafe.AsRef<bool>(&NativePtr->ConfigDockingTransparentPayload);

	public unsafe ref bool ConfigViewportsNoAutoMerge => ref Unsafe.AsRef<bool>(&NativePtr->ConfigViewportsNoAutoMerge);

	public unsafe ref bool ConfigViewportsNoTaskBarIcon => ref Unsafe.AsRef<bool>(&NativePtr->ConfigViewportsNoTaskBarIcon);

	public unsafe ref bool ConfigViewportsNoDecoration => ref Unsafe.AsRef<bool>(&NativePtr->ConfigViewportsNoDecoration);

	public unsafe ref bool ConfigViewportsNoDefaultParent => ref Unsafe.AsRef<bool>(&NativePtr->ConfigViewportsNoDefaultParent);

	public unsafe ref bool MouseDrawCursor => ref Unsafe.AsRef<bool>(&NativePtr->MouseDrawCursor);

	public unsafe ref bool ConfigMacOSXBehaviors => ref Unsafe.AsRef<bool>(&NativePtr->ConfigMacOSXBehaviors);

	public unsafe ref bool ConfigInputTrickleEventQueue => ref Unsafe.AsRef<bool>(&NativePtr->ConfigInputTrickleEventQueue);

	public unsafe ref bool ConfigInputTextCursorBlink => ref Unsafe.AsRef<bool>(&NativePtr->ConfigInputTextCursorBlink);

	public unsafe ref bool ConfigInputTextEnterKeepActive => ref Unsafe.AsRef<bool>(&NativePtr->ConfigInputTextEnterKeepActive);

	public unsafe ref bool ConfigDragClickToInputText => ref Unsafe.AsRef<bool>(&NativePtr->ConfigDragClickToInputText);

	public unsafe ref bool ConfigWindowsResizeFromEdges => ref Unsafe.AsRef<bool>(&NativePtr->ConfigWindowsResizeFromEdges);

	public unsafe ref bool ConfigWindowsMoveFromTitleBarOnly => ref Unsafe.AsRef<bool>(&NativePtr->ConfigWindowsMoveFromTitleBarOnly);

	public unsafe ref float ConfigMemoryCompactTimer => ref Unsafe.AsRef<float>(&NativePtr->ConfigMemoryCompactTimer);

	public unsafe NullTerminatedString BackendPlatformName => new NullTerminatedString(NativePtr->BackendPlatformName);

	public unsafe NullTerminatedString BackendRendererName => new NullTerminatedString(NativePtr->BackendRendererName);

	public unsafe IntPtr BackendPlatformUserData
	{
		get
		{
			return (IntPtr)NativePtr->BackendPlatformUserData;
		}
		set
		{
			NativePtr->BackendPlatformUserData = (void*)value;
		}
	}

	public unsafe IntPtr BackendRendererUserData
	{
		get
		{
			return (IntPtr)NativePtr->BackendRendererUserData;
		}
		set
		{
			NativePtr->BackendRendererUserData = (void*)value;
		}
	}

	public unsafe IntPtr BackendLanguageUserData
	{
		get
		{
			return (IntPtr)NativePtr->BackendLanguageUserData;
		}
		set
		{
			NativePtr->BackendLanguageUserData = (void*)value;
		}
	}

	public unsafe ref IntPtr GetClipboardTextFn => ref Unsafe.AsRef<IntPtr>(&NativePtr->GetClipboardTextFn);

	public unsafe ref IntPtr SetClipboardTextFn => ref Unsafe.AsRef<IntPtr>(&NativePtr->SetClipboardTextFn);

	public unsafe IntPtr ClipboardUserData
	{
		get
		{
			return (IntPtr)NativePtr->ClipboardUserData;
		}
		set
		{
			NativePtr->ClipboardUserData = (void*)value;
		}
	}

	public unsafe ref IntPtr SetPlatformImeDataFn => ref Unsafe.AsRef<IntPtr>(&NativePtr->SetPlatformImeDataFn);

	public unsafe IntPtr _UnusedPadding
	{
		get
		{
			return (IntPtr)NativePtr->_UnusedPadding;
		}
		set
		{
			NativePtr->_UnusedPadding = (void*)value;
		}
	}

	public unsafe ref bool WantCaptureMouse => ref Unsafe.AsRef<bool>(&NativePtr->WantCaptureMouse);

	public unsafe ref bool WantCaptureKeyboard => ref Unsafe.AsRef<bool>(&NativePtr->WantCaptureKeyboard);

	public unsafe ref bool WantTextInput => ref Unsafe.AsRef<bool>(&NativePtr->WantTextInput);

	public unsafe ref bool WantSetMousePos => ref Unsafe.AsRef<bool>(&NativePtr->WantSetMousePos);

	public unsafe ref bool WantSaveIniSettings => ref Unsafe.AsRef<bool>(&NativePtr->WantSaveIniSettings);

	public unsafe ref bool NavActive => ref Unsafe.AsRef<bool>(&NativePtr->NavActive);

	public unsafe ref bool NavVisible => ref Unsafe.AsRef<bool>(&NativePtr->NavVisible);

	public unsafe ref float Framerate => ref Unsafe.AsRef<float>(&NativePtr->Framerate);

	public unsafe ref int MetricsRenderVertices => ref Unsafe.AsRef<int>(&NativePtr->MetricsRenderVertices);

	public unsafe ref int MetricsRenderIndices => ref Unsafe.AsRef<int>(&NativePtr->MetricsRenderIndices);

	public unsafe ref int MetricsRenderWindows => ref Unsafe.AsRef<int>(&NativePtr->MetricsRenderWindows);

	public unsafe ref int MetricsActiveWindows => ref Unsafe.AsRef<int>(&NativePtr->MetricsActiveWindows);

	public unsafe ref int MetricsActiveAllocations => ref Unsafe.AsRef<int>(&NativePtr->MetricsActiveAllocations);

	public unsafe ref Vector2 MouseDelta => ref Unsafe.AsRef<Vector2>(&NativePtr->MouseDelta);

	public unsafe RangeAccessor<int> KeyMap => new RangeAccessor<int>(NativePtr->KeyMap, 652);

	public unsafe RangeAccessor<bool> KeysDown => new RangeAccessor<bool>(NativePtr->KeysDown, 652);

	public unsafe RangeAccessor<float> NavInputs => new RangeAccessor<float>(NativePtr->NavInputs, 16);

	public unsafe ref Vector2 MousePos => ref Unsafe.AsRef<Vector2>(&NativePtr->MousePos);

	public unsafe RangeAccessor<bool> MouseDown => new RangeAccessor<bool>(NativePtr->MouseDown, 5);

	public unsafe ref float MouseWheel => ref Unsafe.AsRef<float>(&NativePtr->MouseWheel);

	public unsafe ref float MouseWheelH => ref Unsafe.AsRef<float>(&NativePtr->MouseWheelH);

	public unsafe ref uint MouseHoveredViewport => ref Unsafe.AsRef<uint>(&NativePtr->MouseHoveredViewport);

	public unsafe ref bool KeyCtrl => ref Unsafe.AsRef<bool>(&NativePtr->KeyCtrl);

	public unsafe ref bool KeyShift => ref Unsafe.AsRef<bool>(&NativePtr->KeyShift);

	public unsafe ref bool KeyAlt => ref Unsafe.AsRef<bool>(&NativePtr->KeyAlt);

	public unsafe ref bool KeySuper => ref Unsafe.AsRef<bool>(&NativePtr->KeySuper);

	public unsafe ref ImGuiKey KeyMods => ref Unsafe.AsRef<ImGuiKey>(&NativePtr->KeyMods);

	public unsafe RangeAccessor<ImGuiKeyData> KeysData => new RangeAccessor<ImGuiKeyData>(&NativePtr->KeysData_0, 652);

	public unsafe ref bool WantCaptureMouseUnlessPopupClose => ref Unsafe.AsRef<bool>(&NativePtr->WantCaptureMouseUnlessPopupClose);

	public unsafe ref Vector2 MousePosPrev => ref Unsafe.AsRef<Vector2>(&NativePtr->MousePosPrev);

	public unsafe RangeAccessor<Vector2> MouseClickedPos => new RangeAccessor<Vector2>(&NativePtr->MouseClickedPos_0, 5);

	public unsafe RangeAccessor<double> MouseClickedTime => new RangeAccessor<double>(NativePtr->MouseClickedTime, 5);

	public unsafe RangeAccessor<bool> MouseClicked => new RangeAccessor<bool>(NativePtr->MouseClicked, 5);

	public unsafe RangeAccessor<bool> MouseDoubleClicked => new RangeAccessor<bool>(NativePtr->MouseDoubleClicked, 5);

	public unsafe RangeAccessor<ushort> MouseClickedCount => new RangeAccessor<ushort>(NativePtr->MouseClickedCount, 5);

	public unsafe RangeAccessor<ushort> MouseClickedLastCount => new RangeAccessor<ushort>(NativePtr->MouseClickedLastCount, 5);

	public unsafe RangeAccessor<bool> MouseReleased => new RangeAccessor<bool>(NativePtr->MouseReleased, 5);

	public unsafe RangeAccessor<bool> MouseDownOwned => new RangeAccessor<bool>(NativePtr->MouseDownOwned, 5);

	public unsafe RangeAccessor<bool> MouseDownOwnedUnlessPopupClose => new RangeAccessor<bool>(NativePtr->MouseDownOwnedUnlessPopupClose, 5);

	public unsafe RangeAccessor<float> MouseDownDuration => new RangeAccessor<float>(NativePtr->MouseDownDuration, 5);

	public unsafe RangeAccessor<float> MouseDownDurationPrev => new RangeAccessor<float>(NativePtr->MouseDownDurationPrev, 5);

	public unsafe RangeAccessor<Vector2> MouseDragMaxDistanceAbs => new RangeAccessor<Vector2>(&NativePtr->MouseDragMaxDistanceAbs_0, 5);

	public unsafe RangeAccessor<float> MouseDragMaxDistanceSqr => new RangeAccessor<float>(NativePtr->MouseDragMaxDistanceSqr, 5);

	public unsafe ref float PenPressure => ref Unsafe.AsRef<float>(&NativePtr->PenPressure);

	public unsafe ref bool AppFocusLost => ref Unsafe.AsRef<bool>(&NativePtr->AppFocusLost);

	public unsafe ref bool AppAcceptingEvents => ref Unsafe.AsRef<bool>(&NativePtr->AppAcceptingEvents);

	public unsafe ref sbyte BackendUsingLegacyKeyArrays => ref Unsafe.AsRef<sbyte>(&NativePtr->BackendUsingLegacyKeyArrays);

	public unsafe ref bool BackendUsingLegacyNavInputArray => ref Unsafe.AsRef<bool>(&NativePtr->BackendUsingLegacyNavInputArray);

	public unsafe ref ushort InputQueueSurrogate => ref Unsafe.AsRef<ushort>(&NativePtr->InputQueueSurrogate);

	public unsafe ImVector<ushort> InputQueueCharacters => new ImVector<ushort>(NativePtr->InputQueueCharacters);

	public unsafe ImGuiIOPtr(ImGuiIO* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImGuiIOPtr(IntPtr nativePtr)
	{
		NativePtr = (ImGuiIO*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImGuiIOPtr(ImGuiIO* nativePtr)
	{
		return new ImGuiIOPtr(nativePtr);
	}

	public unsafe static implicit operator ImGuiIO*(ImGuiIOPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImGuiIOPtr(IntPtr nativePtr)
	{
		return new ImGuiIOPtr(nativePtr);
	}

	public unsafe void AddFocusEvent(bool focused)
	{
		byte focused2 = (byte)(focused ? 1 : 0);
		ImGuiNative.ImGuiIO_AddFocusEvent(NativePtr, focused2);
	}

	public unsafe void AddInputCharacter(uint c)
	{
		ImGuiNative.ImGuiIO_AddInputCharacter(NativePtr, c);
	}

	public unsafe void AddInputCharactersUTF8(string str)
	{
		int num = 0;
		byte* ptr;
		if (str != null)
		{
			num = Encoding.UTF8.GetByteCount(str);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.ImGuiIO_AddInputCharactersUTF8(NativePtr, ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe void AddInputCharacterUTF16(ushort c)
	{
		ImGuiNative.ImGuiIO_AddInputCharacterUTF16(NativePtr, c);
	}

	public unsafe void AddKeyAnalogEvent(ImGuiKey key, bool down, float v)
	{
		byte down2 = (byte)(down ? 1 : 0);
		ImGuiNative.ImGuiIO_AddKeyAnalogEvent(NativePtr, key, down2, v);
	}

	public unsafe void AddKeyEvent(ImGuiKey key, bool down)
	{
		byte down2 = (byte)(down ? 1 : 0);
		ImGuiNative.ImGuiIO_AddKeyEvent(NativePtr, key, down2);
	}

	public unsafe void AddMouseButtonEvent(int button, bool down)
	{
		byte down2 = (byte)(down ? 1 : 0);
		ImGuiNative.ImGuiIO_AddMouseButtonEvent(NativePtr, button, down2);
	}

	public unsafe void AddMousePosEvent(float x, float y)
	{
		ImGuiNative.ImGuiIO_AddMousePosEvent(NativePtr, x, y);
	}

	public unsafe void AddMouseViewportEvent(uint id)
	{
		ImGuiNative.ImGuiIO_AddMouseViewportEvent(NativePtr, id);
	}

	public unsafe void AddMouseWheelEvent(float wh_x, float wh_y)
	{
		ImGuiNative.ImGuiIO_AddMouseWheelEvent(NativePtr, wh_x, wh_y);
	}

	public unsafe void ClearInputCharacters()
	{
		ImGuiNative.ImGuiIO_ClearInputCharacters(NativePtr);
	}

	public unsafe void ClearInputKeys()
	{
		ImGuiNative.ImGuiIO_ClearInputKeys(NativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImGuiIO_destroy(NativePtr);
	}

	public unsafe void SetAppAcceptingEvents(bool accepting_events)
	{
		byte accepting_events2 = (byte)(accepting_events ? 1 : 0);
		ImGuiNative.ImGuiIO_SetAppAcceptingEvents(NativePtr, accepting_events2);
	}

	public unsafe void SetKeyEventNativeData(ImGuiKey key, int native_keycode, int native_scancode)
	{
		int native_legacy_index = -1;
		ImGuiNative.ImGuiIO_SetKeyEventNativeData(NativePtr, key, native_keycode, native_scancode, native_legacy_index);
	}

	public unsafe void SetKeyEventNativeData(ImGuiKey key, int native_keycode, int native_scancode, int native_legacy_index)
	{
		ImGuiNative.ImGuiIO_SetKeyEventNativeData(NativePtr, key, native_keycode, native_scancode, native_legacy_index);
	}
}
public enum ImGuiKey
{
	None = 0,
	Tab = 512,
	LeftArrow = 513,
	RightArrow = 514,
	UpArrow = 515,
	DownArrow = 516,
	PageUp = 517,
	PageDown = 518,
	Home = 519,
	End = 520,
	Insert = 521,
	Delete = 522,
	Backspace = 523,
	Space = 524,
	Enter = 525,
	Escape = 526,
	LeftCtrl = 527,
	LeftShift = 528,
	LeftAlt = 529,
	LeftSuper = 530,
	RightCtrl = 531,
	RightShift = 532,
	RightAlt = 533,
	RightSuper = 534,
	Menu = 535,
	_0 = 536,
	_1 = 537,
	_2 = 538,
	_3 = 539,
	_4 = 540,
	_5 = 541,
	_6 = 542,
	_7 = 543,
	_8 = 544,
	_9 = 545,
	A = 546,
	B = 547,
	C = 548,
	D = 549,
	E = 550,
	F = 551,
	G = 552,
	H = 553,
	I = 554,
	J = 555,
	K = 556,
	L = 557,
	M = 558,
	N = 559,
	O = 560,
	P = 561,
	Q = 562,
	R = 563,
	S = 564,
	T = 565,
	U = 566,
	V = 567,
	W = 568,
	X = 569,
	Y = 570,
	Z = 571,
	F1 = 572,
	F2 = 573,
	F3 = 574,
	F4 = 575,
	F5 = 576,
	F6 = 577,
	F7 = 578,
	F8 = 579,
	F9 = 580,
	F10 = 581,
	F11 = 582,
	F12 = 583,
	Apostrophe = 584,
	Comma = 585,
	Minus = 586,
	Period = 587,
	Slash = 588,
	Semicolon = 589,
	Equal = 590,
	LeftBracket = 591,
	Backslash = 592,
	RightBracket = 593,
	GraveAccent = 594,
	CapsLock = 595,
	ScrollLock = 596,
	NumLock = 597,
	PrintScreen = 598,
	Pause = 599,
	Keypad0 = 600,
	Keypad1 = 601,
	Keypad2 = 602,
	Keypad3 = 603,
	Keypad4 = 604,
	Keypad5 = 605,
	Keypad6 = 606,
	Keypad7 = 607,
	Keypad8 = 608,
	Keypad9 = 609,
	KeypadDecimal = 610,
	KeypadDivide = 611,
	KeypadMultiply = 612,
	KeypadSubtract = 613,
	KeypadAdd = 614,
	KeypadEnter = 615,
	KeypadEqual = 616,
	GamepadStart = 617,
	GamepadBack = 618,
	GamepadFaceLeft = 619,
	GamepadFaceRight = 620,
	GamepadFaceUp = 621,
	GamepadFaceDown = 622,
	GamepadDpadLeft = 623,
	GamepadDpadRight = 624,
	GamepadDpadUp = 625,
	GamepadDpadDown = 626,
	GamepadL1 = 627,
	GamepadR1 = 628,
	GamepadL2 = 629,
	GamepadR2 = 630,
	GamepadL3 = 631,
	GamepadR3 = 632,
	GamepadLStickLeft = 633,
	GamepadLStickRight = 634,
	GamepadLStickUp = 635,
	GamepadLStickDown = 636,
	GamepadRStickLeft = 637,
	GamepadRStickRight = 638,
	GamepadRStickUp = 639,
	GamepadRStickDown = 640,
	MouseLeft = 641,
	MouseRight = 642,
	MouseMiddle = 643,
	MouseX1 = 644,
	MouseX2 = 645,
	MouseWheelX = 646,
	MouseWheelY = 647,
	ReservedForModCtrl = 648,
	ReservedForModShift = 649,
	ReservedForModAlt = 650,
	ReservedForModSuper = 651,
	COUNT = 652,
	ImGuiMod_None = 0,
	ImGuiMod_Ctrl = 4096,
	ImGuiMod_Shift = 8192,
	ImGuiMod_Alt = 16384,
	ImGuiMod_Super = 32768,
	ImGuiMod_Mask = 61440,
	ImGuiMod_Shortcut = 4096,
	NamedKey_BEGIN = 512,
	NamedKey_END = 652,
	NamedKey_COUNT = 140,
	KeysData_SIZE = 652,
	KeysData_OFFSET = 0
}
public struct ImGuiKeyData
{
	public byte Down;

	public float DownDuration;

	public float DownDurationPrev;

	public float AnalogValue;
}
public struct ImGuiKeyDataPtr
{
	public unsafe ImGuiKeyData* NativePtr { get; }

	public unsafe ref bool Down => ref Unsafe.AsRef<bool>(&NativePtr->Down);

	public unsafe ref float DownDuration => ref Unsafe.AsRef<float>(&NativePtr->DownDuration);

	public unsafe ref float DownDurationPrev => ref Unsafe.AsRef<float>(&NativePtr->DownDurationPrev);

	public unsafe ref float AnalogValue => ref Unsafe.AsRef<float>(&NativePtr->AnalogValue);

	public unsafe ImGuiKeyDataPtr(ImGuiKeyData* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImGuiKeyDataPtr(IntPtr nativePtr)
	{
		NativePtr = (ImGuiKeyData*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImGuiKeyDataPtr(ImGuiKeyData* nativePtr)
	{
		return new ImGuiKeyDataPtr(nativePtr);
	}

	public unsafe static implicit operator ImGuiKeyData*(ImGuiKeyDataPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImGuiKeyDataPtr(IntPtr nativePtr)
	{
		return new ImGuiKeyDataPtr(nativePtr);
	}
}
public struct ImGuiListClipper
{
	public int DisplayStart;

	public int DisplayEnd;

	public int ItemsCount;

	public float ItemsHeight;

	public float StartPosY;

	public unsafe void* TempData;
}
public struct ImGuiListClipperPtr
{
	public unsafe ImGuiListClipper* NativePtr { get; }

	public unsafe ref int DisplayStart => ref Unsafe.AsRef<int>(&NativePtr->DisplayStart);

	public unsafe ref int DisplayEnd => ref Unsafe.AsRef<int>(&NativePtr->DisplayEnd);

	public unsafe ref int ItemsCount => ref Unsafe.AsRef<int>(&NativePtr->ItemsCount);

	public unsafe ref float ItemsHeight => ref Unsafe.AsRef<float>(&NativePtr->ItemsHeight);

	public unsafe ref float StartPosY => ref Unsafe.AsRef<float>(&NativePtr->StartPosY);

	public unsafe IntPtr TempData
	{
		get
		{
			return (IntPtr)NativePtr->TempData;
		}
		set
		{
			NativePtr->TempData = (void*)value;
		}
	}

	public unsafe ImGuiListClipperPtr(ImGuiListClipper* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImGuiListClipperPtr(IntPtr nativePtr)
	{
		NativePtr = (ImGuiListClipper*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImGuiListClipperPtr(ImGuiListClipper* nativePtr)
	{
		return new ImGuiListClipperPtr(nativePtr);
	}

	public unsafe static implicit operator ImGuiListClipper*(ImGuiListClipperPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImGuiListClipperPtr(IntPtr nativePtr)
	{
		return new ImGuiListClipperPtr(nativePtr);
	}

	public unsafe void Begin(int items_count)
	{
		float items_height = -1f;
		ImGuiNative.ImGuiListClipper_Begin(NativePtr, items_count, items_height);
	}

	public unsafe void Begin(int items_count, float items_height)
	{
		ImGuiNative.ImGuiListClipper_Begin(NativePtr, items_count, items_height);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImGuiListClipper_destroy(NativePtr);
	}

	public unsafe void End()
	{
		ImGuiNative.ImGuiListClipper_End(NativePtr);
	}

	public unsafe void ForceDisplayRangeByIndices(int item_min, int item_max)
	{
		ImGuiNative.ImGuiListClipper_ForceDisplayRangeByIndices(NativePtr, item_min, item_max);
	}

	public unsafe bool Step()
	{
		return ImGuiNative.ImGuiListClipper_Step(NativePtr) != 0;
	}
}
[Flags]
public enum ImGuiModFlags
{
	None = 0,
	Ctrl = 1,
	Shift = 2,
	Alt = 4,
	Super = 8
}
public enum ImGuiMouseButton
{
	Left = 0,
	Right = 1,
	Middle = 2,
	COUNT = 5
}
public enum ImGuiMouseCursor
{
	None = -1,
	Arrow,
	TextInput,
	ResizeAll,
	ResizeNS,
	ResizeEW,
	ResizeNESW,
	ResizeNWSE,
	Hand,
	NotAllowed,
	COUNT
}
public static class ImGuiNative
{
	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiPayload* igAcceptDragDropPayload(byte* type, ImGuiDragDropFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igAlignTextToFramePadding();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igArrowButton(byte* str_id, ImGuiDir dir);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igBegin(byte* name, byte* p_open, ImGuiWindowFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igBeginChild_Str(byte* str_id, Vector2 size, byte border, ImGuiWindowFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igBeginChild_ID(uint id, Vector2 size, byte border, ImGuiWindowFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igBeginChildFrame(uint id, Vector2 size, ImGuiWindowFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igBeginCombo(byte* label, byte* preview_value, ImGuiComboFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igBeginDisabled(byte disabled);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igBeginDragDropSource(ImGuiDragDropFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igBeginDragDropTarget();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igBeginGroup();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igBeginListBox(byte* label, Vector2 size);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igBeginMainMenuBar();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igBeginMenu(byte* label, byte enabled);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igBeginMenuBar();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igBeginPopup(byte* str_id, ImGuiWindowFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igBeginPopupContextItem(byte* str_id, ImGuiPopupFlags popup_flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igBeginPopupContextVoid(byte* str_id, ImGuiPopupFlags popup_flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igBeginPopupContextWindow(byte* str_id, ImGuiPopupFlags popup_flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igBeginPopupModal(byte* name, byte* p_open, ImGuiWindowFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igBeginTabBar(byte* str_id, ImGuiTabBarFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igBeginTabItem(byte* label, byte* p_open, ImGuiTabItemFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igBeginTable(byte* str_id, int column, ImGuiTableFlags flags, Vector2 outer_size, float inner_width);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igBeginTooltip();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igBullet();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igBulletText(byte* fmt);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igButton(byte* label, Vector2 size);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern float igCalcItemWidth();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igCalcTextSize(Vector2* pOut, byte* text, byte* text_end, byte hide_text_after_double_hash, float wrap_width);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igCheckbox(byte* label, byte* v);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igCheckboxFlags_IntPtr(byte* label, int* flags, int flags_value);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igCheckboxFlags_UintPtr(byte* label, uint* flags, uint flags_value);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igCloseCurrentPopup();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igCollapsingHeader_TreeNodeFlags(byte* label, ImGuiTreeNodeFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igCollapsingHeader_BoolPtr(byte* label, byte* p_visible, ImGuiTreeNodeFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igColorButton(byte* desc_id, Vector4 col, ImGuiColorEditFlags flags, Vector2 size);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern uint igColorConvertFloat4ToU32(Vector4 @in);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igColorConvertHSVtoRGB(float h, float s, float v, float* out_r, float* out_g, float* out_b);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igColorConvertRGBtoHSV(float r, float g, float b, float* out_h, float* out_s, float* out_v);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igColorConvertU32ToFloat4(Vector4* pOut, uint @in);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igColorEdit3(byte* label, Vector3* col, ImGuiColorEditFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igColorEdit4(byte* label, Vector4* col, ImGuiColorEditFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igColorPicker3(byte* label, Vector3* col, ImGuiColorEditFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igColorPicker4(byte* label, Vector4* col, ImGuiColorEditFlags flags, float* ref_col);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igColumns(int count, byte* id, byte border);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igCombo_Str_arr(byte* label, int* current_item, byte** items, int items_count, int popup_max_height_in_items);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igCombo_Str(byte* label, int* current_item, byte* items_separated_by_zeros, int popup_max_height_in_items);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern IntPtr igCreateContext(ImFontAtlas* shared_font_atlas);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igDebugCheckVersionAndDataLayout(byte* version_str, uint sz_io, uint sz_style, uint sz_vec2, uint sz_vec4, uint sz_drawvert, uint sz_drawidx);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igDebugTextEncoding(byte* text);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igDestroyContext(IntPtr ctx);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igDestroyPlatformWindows();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern uint igDockSpace(uint id, Vector2 size, ImGuiDockNodeFlags flags, ImGuiWindowClass* window_class);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern uint igDockSpaceOverViewport(ImGuiViewport* viewport, ImGuiDockNodeFlags flags, ImGuiWindowClass* window_class);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igDragFloat(byte* label, float* v, float v_speed, float v_min, float v_max, byte* format, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igDragFloat2(byte* label, Vector2* v, float v_speed, float v_min, float v_max, byte* format, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igDragFloat3(byte* label, Vector3* v, float v_speed, float v_min, float v_max, byte* format, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igDragFloat4(byte* label, Vector4* v, float v_speed, float v_min, float v_max, byte* format, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igDragFloatRange2(byte* label, float* v_current_min, float* v_current_max, float v_speed, float v_min, float v_max, byte* format, byte* format_max, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igDragInt(byte* label, int* v, float v_speed, int v_min, int v_max, byte* format, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igDragInt2(byte* label, int* v, float v_speed, int v_min, int v_max, byte* format, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igDragInt3(byte* label, int* v, float v_speed, int v_min, int v_max, byte* format, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igDragInt4(byte* label, int* v, float v_speed, int v_min, int v_max, byte* format, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igDragIntRange2(byte* label, int* v_current_min, int* v_current_max, float v_speed, int v_min, int v_max, byte* format, byte* format_max, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igDragScalar(byte* label, ImGuiDataType data_type, void* p_data, float v_speed, void* p_min, void* p_max, byte* format, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igDragScalarN(byte* label, ImGuiDataType data_type, void* p_data, int components, float v_speed, void* p_min, void* p_max, byte* format, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igDummy(Vector2 size);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igEnd();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igEndChild();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igEndChildFrame();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igEndCombo();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igEndDisabled();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igEndDragDropSource();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igEndDragDropTarget();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igEndFrame();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igEndGroup();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igEndListBox();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igEndMainMenuBar();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igEndMenu();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igEndMenuBar();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igEndPopup();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igEndTabBar();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igEndTabItem();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igEndTable();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igEndTooltip();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiViewport* igFindViewportByID(uint id);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiViewport* igFindViewportByPlatformHandle(void* platform_handle);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igGetAllocatorFunctions(IntPtr* p_alloc_func, IntPtr* p_free_func, void** p_user_data);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImDrawList* igGetBackgroundDrawList_Nil();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImDrawList* igGetBackgroundDrawList_ViewportPtr(ImGuiViewport* viewport);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte* igGetClipboardText();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern uint igGetColorU32_Col(ImGuiCol idx, float alpha_mul);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern uint igGetColorU32_Vec4(Vector4 col);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern uint igGetColorU32_U32(uint col);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern int igGetColumnIndex();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern float igGetColumnOffset(int column_index);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern int igGetColumnsCount();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern float igGetColumnWidth(int column_index);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igGetContentRegionAvail(Vector2* pOut);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igGetContentRegionMax(Vector2* pOut);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern IntPtr igGetCurrentContext();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igGetCursorPos(Vector2* pOut);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern float igGetCursorPosX();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern float igGetCursorPosY();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igGetCursorScreenPos(Vector2* pOut);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igGetCursorStartPos(Vector2* pOut);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiPayload* igGetDragDropPayload();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImDrawData* igGetDrawData();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern IntPtr igGetDrawListSharedData();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImFont* igGetFont();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern float igGetFontSize();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igGetFontTexUvWhitePixel(Vector2* pOut);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImDrawList* igGetForegroundDrawList_Nil();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImDrawList* igGetForegroundDrawList_ViewportPtr(ImGuiViewport* viewport);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern int igGetFrameCount();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern float igGetFrameHeight();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern float igGetFrameHeightWithSpacing();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern uint igGetID_Str(byte* str_id);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern uint igGetID_StrStr(byte* str_id_begin, byte* str_id_end);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern uint igGetID_Ptr(void* ptr_id);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiIO* igGetIO();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igGetItemRectMax(Vector2* pOut);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igGetItemRectMin(Vector2* pOut);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igGetItemRectSize(Vector2* pOut);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern ImGuiKey igGetKeyIndex(ImGuiKey key);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte* igGetKeyName(ImGuiKey key);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern int igGetKeyPressedAmount(ImGuiKey key, float repeat_delay, float rate);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiViewport* igGetMainViewport();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern int igGetMouseClickedCount(ImGuiMouseButton button);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern ImGuiMouseCursor igGetMouseCursor();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igGetMouseDragDelta(Vector2* pOut, ImGuiMouseButton button, float lock_threshold);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igGetMousePos(Vector2* pOut);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igGetMousePosOnOpeningCurrentPopup(Vector2* pOut);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiPlatformIO* igGetPlatformIO();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern float igGetScrollMaxX();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern float igGetScrollMaxY();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern float igGetScrollX();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern float igGetScrollY();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiStorage* igGetStateStorage();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiStyle* igGetStyle();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte* igGetStyleColorName(ImGuiCol idx);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern Vector4* igGetStyleColorVec4(ImGuiCol idx);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern float igGetTextLineHeight();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern float igGetTextLineHeightWithSpacing();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern double igGetTime();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern float igGetTreeNodeToLabelSpacing();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte* igGetVersion();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igGetWindowContentRegionMax(Vector2* pOut);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igGetWindowContentRegionMin(Vector2* pOut);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern uint igGetWindowDockID();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern float igGetWindowDpiScale();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImDrawList* igGetWindowDrawList();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern float igGetWindowHeight();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igGetWindowPos(Vector2* pOut);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igGetWindowSize(Vector2* pOut);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiViewport* igGetWindowViewport();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern float igGetWindowWidth();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igImage(IntPtr user_texture_id, Vector2 size, Vector2 uv0, Vector2 uv1, Vector4 tint_col, Vector4 border_col);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igImageButton(byte* str_id, IntPtr user_texture_id, Vector2 size, Vector2 uv0, Vector2 uv1, Vector4 bg_col, Vector4 tint_col);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igIndent(float indent_w);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igInputDouble(byte* label, double* v, double step, double step_fast, byte* format, ImGuiInputTextFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igInputFloat(byte* label, float* v, float step, float step_fast, byte* format, ImGuiInputTextFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igInputFloat2(byte* label, Vector2* v, byte* format, ImGuiInputTextFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igInputFloat3(byte* label, Vector3* v, byte* format, ImGuiInputTextFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igInputFloat4(byte* label, Vector4* v, byte* format, ImGuiInputTextFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igInputInt(byte* label, int* v, int step, int step_fast, ImGuiInputTextFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igInputInt2(byte* label, int* v, ImGuiInputTextFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igInputInt3(byte* label, int* v, ImGuiInputTextFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igInputInt4(byte* label, int* v, ImGuiInputTextFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igInputScalar(byte* label, ImGuiDataType data_type, void* p_data, void* p_step, void* p_step_fast, byte* format, ImGuiInputTextFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igInputScalarN(byte* label, ImGuiDataType data_type, void* p_data, int components, void* p_step, void* p_step_fast, byte* format, ImGuiInputTextFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igInputText(byte* label, byte* buf, uint buf_size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igInputTextMultiline(byte* label, byte* buf, uint buf_size, Vector2 size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igInputTextWithHint(byte* label, byte* hint, byte* buf, uint buf_size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igInvisibleButton(byte* str_id, Vector2 size, ImGuiButtonFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsAnyItemActive();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsAnyItemFocused();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsAnyItemHovered();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsAnyMouseDown();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsItemActivated();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsItemActive();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsItemClicked(ImGuiMouseButton mouse_button);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsItemDeactivated();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsItemDeactivatedAfterEdit();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsItemEdited();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsItemFocused();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsItemHovered(ImGuiHoveredFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsItemToggledOpen();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsItemVisible();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsKeyDown_Nil(ImGuiKey key);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsKeyPressed_Bool(ImGuiKey key, byte repeat);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsKeyReleased_Nil(ImGuiKey key);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsMouseClicked_Bool(ImGuiMouseButton button, byte repeat);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsMouseDoubleClicked(ImGuiMouseButton button);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsMouseDown_Nil(ImGuiMouseButton button);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsMouseDragging(ImGuiMouseButton button, float lock_threshold);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsMouseHoveringRect(Vector2 r_min, Vector2 r_max, byte clip);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igIsMousePosValid(Vector2* mouse_pos);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsMouseReleased_Nil(ImGuiMouseButton button);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igIsPopupOpen_Str(byte* str_id, ImGuiPopupFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsRectVisible_Nil(Vector2 size);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsRectVisible_Vec2(Vector2 rect_min, Vector2 rect_max);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsWindowAppearing();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsWindowCollapsed();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsWindowDocked();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsWindowFocused(ImGuiFocusedFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igIsWindowHovered(ImGuiHoveredFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igLabelText(byte* label, byte* fmt);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igListBox_Str_arr(byte* label, int* current_item, byte** items, int items_count, int height_in_items);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igLoadIniSettingsFromDisk(byte* ini_filename);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igLoadIniSettingsFromMemory(byte* ini_data, uint ini_size);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igLogButtons();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igLogFinish();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igLogText(byte* fmt);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igLogToClipboard(int auto_open_depth);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igLogToFile(int auto_open_depth, byte* filename);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igLogToTTY(int auto_open_depth);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void* igMemAlloc(uint size);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igMemFree(void* ptr);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igMenuItem_Bool(byte* label, byte* shortcut, byte selected, byte enabled);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igMenuItem_BoolPtr(byte* label, byte* shortcut, byte* p_selected, byte enabled);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igNewFrame();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igNewLine();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igNextColumn();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igOpenPopup_Str(byte* str_id, ImGuiPopupFlags popup_flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igOpenPopup_ID(uint id, ImGuiPopupFlags popup_flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igOpenPopupOnItemClick(byte* str_id, ImGuiPopupFlags popup_flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igPlotHistogram_FloatPtr(byte* label, float* values, int values_count, int values_offset, byte* overlay_text, float scale_min, float scale_max, Vector2 graph_size, int stride);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igPlotLines_FloatPtr(byte* label, float* values, int values_count, int values_offset, byte* overlay_text, float scale_min, float scale_max, Vector2 graph_size, int stride);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igPopAllowKeyboardFocus();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igPopButtonRepeat();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igPopClipRect();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igPopFont();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igPopID();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igPopItemWidth();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igPopStyleColor(int count);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igPopStyleVar(int count);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igPopTextWrapPos();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igProgressBar(float fraction, Vector2 size_arg, byte* overlay);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igPushAllowKeyboardFocus(byte allow_keyboard_focus);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igPushButtonRepeat(byte repeat);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igPushClipRect(Vector2 clip_rect_min, Vector2 clip_rect_max, byte intersect_with_current_clip_rect);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igPushFont(ImFont* font);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igPushID_Str(byte* str_id);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igPushID_StrStr(byte* str_id_begin, byte* str_id_end);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igPushID_Ptr(void* ptr_id);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igPushID_Int(int int_id);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igPushItemWidth(float item_width);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igPushStyleColor_U32(ImGuiCol idx, uint col);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igPushStyleColor_Vec4(ImGuiCol idx, Vector4 col);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igPushStyleVar_Float(ImGuiStyleVar idx, float val);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igPushStyleVar_Vec2(ImGuiStyleVar idx, Vector2 val);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igPushTextWrapPos(float wrap_local_pos_x);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igRadioButton_Bool(byte* label, byte active);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igRadioButton_IntPtr(byte* label, int* v, int v_button);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igRender();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igRenderPlatformWindowsDefault(void* platform_render_arg, void* renderer_render_arg);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igResetMouseDragDelta(ImGuiMouseButton button);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSameLine(float offset_from_start_x, float spacing);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igSaveIniSettingsToDisk(byte* ini_filename);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte* igSaveIniSettingsToMemory(uint* out_ini_size);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igSelectable_Bool(byte* label, byte selected, ImGuiSelectableFlags flags, Vector2 size);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igSelectable_BoolPtr(byte* label, byte* p_selected, ImGuiSelectableFlags flags, Vector2 size);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSeparator();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igSetAllocatorFunctions(IntPtr alloc_func, IntPtr free_func, void* user_data);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igSetClipboardText(byte* text);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetColorEditOptions(ImGuiColorEditFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetColumnOffset(int column_index, float offset_x);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetColumnWidth(int column_index, float width);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetCurrentContext(IntPtr ctx);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetCursorPos(Vector2 local_pos);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetCursorPosX(float local_x);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetCursorPosY(float local_y);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetCursorScreenPos(Vector2 pos);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igSetDragDropPayload(byte* type, void* data, uint sz, ImGuiCond cond);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetItemAllowOverlap();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetItemDefaultFocus();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetKeyboardFocusHere(int offset);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetMouseCursor(ImGuiMouseCursor cursor_type);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetNextFrameWantCaptureKeyboard(byte want_capture_keyboard);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetNextFrameWantCaptureMouse(byte want_capture_mouse);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetNextItemOpen(byte is_open, ImGuiCond cond);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetNextItemWidth(float item_width);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetNextWindowBgAlpha(float alpha);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igSetNextWindowClass(ImGuiWindowClass* window_class);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetNextWindowCollapsed(byte collapsed, ImGuiCond cond);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetNextWindowContentSize(Vector2 size);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetNextWindowDockID(uint dock_id, ImGuiCond cond);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetNextWindowFocus();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetNextWindowPos(Vector2 pos, ImGuiCond cond, Vector2 pivot);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetNextWindowScroll(Vector2 scroll);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetNextWindowSize(Vector2 size, ImGuiCond cond);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igSetNextWindowSizeConstraints(Vector2 size_min, Vector2 size_max, ImGuiSizeCallback custom_callback, void* custom_callback_data);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetNextWindowViewport(uint viewport_id);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetScrollFromPosX_Float(float local_x, float center_x_ratio);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetScrollFromPosY_Float(float local_y, float center_y_ratio);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetScrollHereX(float center_x_ratio);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetScrollHereY(float center_y_ratio);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetScrollX_Float(float scroll_x);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetScrollY_Float(float scroll_y);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igSetStateStorage(ImGuiStorage* storage);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igSetTabItemClosed(byte* tab_or_docked_window_label);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igSetTooltip(byte* fmt);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetWindowCollapsed_Bool(byte collapsed, ImGuiCond cond);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igSetWindowCollapsed_Str(byte* name, byte collapsed, ImGuiCond cond);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetWindowFocus_Nil();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igSetWindowFocus_Str(byte* name);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetWindowFontScale(float scale);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetWindowPos_Vec2(Vector2 pos, ImGuiCond cond);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igSetWindowPos_Str(byte* name, Vector2 pos, ImGuiCond cond);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSetWindowSize_Vec2(Vector2 size, ImGuiCond cond);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igSetWindowSize_Str(byte* name, Vector2 size, ImGuiCond cond);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igShowAboutWindow(byte* p_open);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igShowDebugLogWindow(byte* p_open);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igShowDemoWindow(byte* p_open);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igShowFontSelector(byte* label);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igShowMetricsWindow(byte* p_open);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igShowStackToolWindow(byte* p_open);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igShowStyleEditor(ImGuiStyle* @ref);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igShowStyleSelector(byte* label);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igShowUserGuide();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igSliderAngle(byte* label, float* v_rad, float v_degrees_min, float v_degrees_max, byte* format, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igSliderFloat(byte* label, float* v, float v_min, float v_max, byte* format, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igSliderFloat2(byte* label, Vector2* v, float v_min, float v_max, byte* format, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igSliderFloat3(byte* label, Vector3* v, float v_min, float v_max, byte* format, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igSliderFloat4(byte* label, Vector4* v, float v_min, float v_max, byte* format, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igSliderInt(byte* label, int* v, int v_min, int v_max, byte* format, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igSliderInt2(byte* label, int* v, int v_min, int v_max, byte* format, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igSliderInt3(byte* label, int* v, int v_min, int v_max, byte* format, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igSliderInt4(byte* label, int* v, int v_min, int v_max, byte* format, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igSliderScalar(byte* label, ImGuiDataType data_type, void* p_data, void* p_min, void* p_max, byte* format, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igSliderScalarN(byte* label, ImGuiDataType data_type, void* p_data, int components, void* p_min, void* p_max, byte* format, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igSmallButton(byte* label);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igSpacing();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igStyleColorsClassic(ImGuiStyle* dst);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igStyleColorsDark(ImGuiStyle* dst);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igStyleColorsLight(ImGuiStyle* dst);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igTabItemButton(byte* label, ImGuiTabItemFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern int igTableGetColumnCount();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern ImGuiTableColumnFlags igTableGetColumnFlags(int column_n);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern int igTableGetColumnIndex();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte* igTableGetColumnName_Int(int column_n);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern int igTableGetRowIndex();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiTableSortSpecs* igTableGetSortSpecs();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igTableHeader(byte* label);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igTableHeadersRow();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igTableNextColumn();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igTableNextRow(ImGuiTableRowFlags row_flags, float min_row_height);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igTableSetBgColor(ImGuiTableBgTarget target, uint color, int column_n);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igTableSetColumnEnabled(int column_n, byte v);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern byte igTableSetColumnIndex(int column_n);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igTableSetupColumn(byte* label, ImGuiTableColumnFlags flags, float init_width_or_weight, uint user_id);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igTableSetupScrollFreeze(int cols, int rows);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igText(byte* fmt);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igTextColored(Vector4 col, byte* fmt);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igTextDisabled(byte* fmt);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igTextUnformatted(byte* text, byte* text_end);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igTextWrapped(byte* fmt);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igTreeNode_Str(byte* label);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igTreeNode_StrStr(byte* str_id, byte* fmt);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igTreeNode_Ptr(void* ptr_id, byte* fmt);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igTreeNodeEx_Str(byte* label, ImGuiTreeNodeFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igTreeNodeEx_StrStr(byte* str_id, ImGuiTreeNodeFlags flags, byte* fmt);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igTreeNodeEx_Ptr(void* ptr_id, ImGuiTreeNodeFlags flags, byte* fmt);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igTreePop();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igTreePush_Str(byte* str_id);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igTreePush_Ptr(void* ptr_id);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igUnindent(float indent_w);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public static extern void igUpdatePlatformWindows();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igValue_Bool(byte* prefix, byte b);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igValue_Int(byte* prefix, int v);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igValue_Uint(byte* prefix, uint v);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void igValue_Float(byte* prefix, float v, byte* float_format);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igVSliderFloat(byte* label, Vector2 size, float* v, float v_min, float v_max, byte* format, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igVSliderInt(byte* label, Vector2 size, int* v, int v_min, int v_max, byte* format, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte igVSliderScalar(byte* label, Vector2 size, ImGuiDataType data_type, void* p_data, void* p_min, void* p_max, byte* format, ImGuiSliderFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImColor_destroy(ImColor* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImColor_HSV(ImColor* pOut, float h, float s, float v, float a);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImColor* ImColor_ImColor_Nil();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImColor* ImColor_ImColor_Float(float r, float g, float b, float a);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImColor* ImColor_ImColor_Vec4(Vector4 col);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImColor* ImColor_ImColor_Int(int r, int g, int b, int a);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImColor* ImColor_ImColor_U32(uint rgba);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImColor_SetHSV(ImColor* self, float h, float s, float v, float a);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawCmd_destroy(ImDrawCmd* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern IntPtr ImDrawCmd_GetTexID(ImDrawCmd* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImDrawCmd* ImDrawCmd_ImDrawCmd();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawData_Clear(ImDrawData* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawData_DeIndexAllBuffers(ImDrawData* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawData_destroy(ImDrawData* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImDrawData* ImDrawData_ImDrawData();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawData_ScaleClipRects(ImDrawData* self, Vector2 fb_scale);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern int ImDrawList__CalcCircleAutoSegmentCount(ImDrawList* self, float radius);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList__ClearFreeMemory(ImDrawList* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList__OnChangedClipRect(ImDrawList* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList__OnChangedTextureID(ImDrawList* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList__OnChangedVtxOffset(ImDrawList* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList__PathArcToFastEx(ImDrawList* self, Vector2 center, float radius, int a_min_sample, int a_max_sample, int a_step);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList__PathArcToN(ImDrawList* self, Vector2 center, float radius, float a_min, float a_max, int num_segments);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList__PopUnusedDrawCmd(ImDrawList* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList__ResetForNewFrame(ImDrawList* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList__TryMergeDrawCmds(ImDrawList* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_AddBezierCubic(ImDrawList* self, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col, float thickness, int num_segments);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_AddBezierQuadratic(ImDrawList* self, Vector2 p1, Vector2 p2, Vector2 p3, uint col, float thickness, int num_segments);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_AddCallback(ImDrawList* self, IntPtr callback, void* callback_data);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_AddCircle(ImDrawList* self, Vector2 center, float radius, uint col, int num_segments, float thickness);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_AddCircleFilled(ImDrawList* self, Vector2 center, float radius, uint col, int num_segments);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_AddConvexPolyFilled(ImDrawList* self, Vector2* points, int num_points, uint col);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_AddDrawCmd(ImDrawList* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_AddImage(ImDrawList* self, IntPtr user_texture_id, Vector2 p_min, Vector2 p_max, Vector2 uv_min, Vector2 uv_max, uint col);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_AddImageQuad(ImDrawList* self, IntPtr user_texture_id, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 uv1, Vector2 uv2, Vector2 uv3, Vector2 uv4, uint col);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_AddImageRounded(ImDrawList* self, IntPtr user_texture_id, Vector2 p_min, Vector2 p_max, Vector2 uv_min, Vector2 uv_max, uint col, float rounding, ImDrawFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_AddLine(ImDrawList* self, Vector2 p1, Vector2 p2, uint col, float thickness);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_AddNgon(ImDrawList* self, Vector2 center, float radius, uint col, int num_segments, float thickness);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_AddNgonFilled(ImDrawList* self, Vector2 center, float radius, uint col, int num_segments);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_AddPolyline(ImDrawList* self, Vector2* points, int num_points, uint col, ImDrawFlags flags, float thickness);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_AddQuad(ImDrawList* self, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col, float thickness);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_AddQuadFilled(ImDrawList* self, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_AddRect(ImDrawList* self, Vector2 p_min, Vector2 p_max, uint col, float rounding, ImDrawFlags flags, float thickness);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_AddRectFilled(ImDrawList* self, Vector2 p_min, Vector2 p_max, uint col, float rounding, ImDrawFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_AddRectFilledMultiColor(ImDrawList* self, Vector2 p_min, Vector2 p_max, uint col_upr_left, uint col_upr_right, uint col_bot_right, uint col_bot_left);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_AddText_Vec2(ImDrawList* self, Vector2 pos, uint col, byte* text_begin, byte* text_end);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_AddText_FontPtr(ImDrawList* self, ImFont* font, float font_size, Vector2 pos, uint col, byte* text_begin, byte* text_end, float wrap_width, Vector4* cpu_fine_clip_rect);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_AddTriangle(ImDrawList* self, Vector2 p1, Vector2 p2, Vector2 p3, uint col, float thickness);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_AddTriangleFilled(ImDrawList* self, Vector2 p1, Vector2 p2, Vector2 p3, uint col);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_ChannelsMerge(ImDrawList* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_ChannelsSetCurrent(ImDrawList* self, int n);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_ChannelsSplit(ImDrawList* self, int count);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImDrawList* ImDrawList_CloneOutput(ImDrawList* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_destroy(ImDrawList* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_GetClipRectMax(Vector2* pOut, ImDrawList* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_GetClipRectMin(Vector2* pOut, ImDrawList* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImDrawList* ImDrawList_ImDrawList(IntPtr shared_data);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_PathArcTo(ImDrawList* self, Vector2 center, float radius, float a_min, float a_max, int num_segments);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_PathArcToFast(ImDrawList* self, Vector2 center, float radius, int a_min_of_12, int a_max_of_12);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_PathBezierCubicCurveTo(ImDrawList* self, Vector2 p2, Vector2 p3, Vector2 p4, int num_segments);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_PathBezierQuadraticCurveTo(ImDrawList* self, Vector2 p2, Vector2 p3, int num_segments);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_PathClear(ImDrawList* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_PathFillConvex(ImDrawList* self, uint col);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_PathLineTo(ImDrawList* self, Vector2 pos);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_PathLineToMergeDuplicate(ImDrawList* self, Vector2 pos);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_PathRect(ImDrawList* self, Vector2 rect_min, Vector2 rect_max, float rounding, ImDrawFlags flags);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_PathStroke(ImDrawList* self, uint col, ImDrawFlags flags, float thickness);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_PopClipRect(ImDrawList* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_PopTextureID(ImDrawList* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_PrimQuadUV(ImDrawList* self, Vector2 a, Vector2 b, Vector2 c, Vector2 d, Vector2 uv_a, Vector2 uv_b, Vector2 uv_c, Vector2 uv_d, uint col);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_PrimRect(ImDrawList* self, Vector2 a, Vector2 b, uint col);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_PrimRectUV(ImDrawList* self, Vector2 a, Vector2 b, Vector2 uv_a, Vector2 uv_b, uint col);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_PrimReserve(ImDrawList* self, int idx_count, int vtx_count);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_PrimUnreserve(ImDrawList* self, int idx_count, int vtx_count);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_PrimVtx(ImDrawList* self, Vector2 pos, Vector2 uv, uint col);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_PrimWriteIdx(ImDrawList* self, ushort idx);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_PrimWriteVtx(ImDrawList* self, Vector2 pos, Vector2 uv, uint col);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_PushClipRect(ImDrawList* self, Vector2 clip_rect_min, Vector2 clip_rect_max, byte intersect_with_current_clip_rect);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_PushClipRectFullScreen(ImDrawList* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawList_PushTextureID(ImDrawList* self, IntPtr texture_id);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawListSplitter_Clear(ImDrawListSplitter* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawListSplitter_ClearFreeMemory(ImDrawListSplitter* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawListSplitter_destroy(ImDrawListSplitter* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImDrawListSplitter* ImDrawListSplitter_ImDrawListSplitter();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawListSplitter_Merge(ImDrawListSplitter* self, ImDrawList* draw_list);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawListSplitter_SetCurrentChannel(ImDrawListSplitter* self, ImDrawList* draw_list, int channel_idx);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImDrawListSplitter_Split(ImDrawListSplitter* self, ImDrawList* draw_list, int count);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFont_AddGlyph(ImFont* self, ImFontConfig* src_cfg, ushort c, float x0, float y0, float x1, float y1, float u0, float v0, float u1, float v1, float advance_x);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFont_AddRemapChar(ImFont* self, ushort dst, ushort src, byte overwrite_dst);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFont_BuildLookupTable(ImFont* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFont_CalcTextSizeA(Vector2* pOut, ImFont* self, float size, float max_width, float wrap_width, byte* text_begin, byte* text_end, byte** remaining);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte* ImFont_CalcWordWrapPositionA(ImFont* self, float scale, byte* text, byte* text_end, float wrap_width);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFont_ClearOutputData(ImFont* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFont_destroy(ImFont* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImFontGlyph* ImFont_FindGlyph(ImFont* self, ushort c);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImFontGlyph* ImFont_FindGlyphNoFallback(ImFont* self, ushort c);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern float ImFont_GetCharAdvance(ImFont* self, ushort c);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte* ImFont_GetDebugName(ImFont* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFont_GrowIndex(ImFont* self, int new_size);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImFont* ImFont_ImFont();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte ImFont_IsGlyphRangeUnused(ImFont* self, uint c_begin, uint c_last);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte ImFont_IsLoaded(ImFont* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFont_RenderChar(ImFont* self, ImDrawList* draw_list, float size, Vector2 pos, uint col, ushort c);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFont_RenderText(ImFont* self, ImDrawList* draw_list, float size, Vector2 pos, uint col, Vector4 clip_rect, byte* text_begin, byte* text_end, float wrap_width, byte cpu_fine_clip);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFont_SetGlyphVisible(ImFont* self, ushort c, byte visible);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern int ImFontAtlas_AddCustomRectFontGlyph(ImFontAtlas* self, ImFont* font, ushort id, int width, int height, float advance_x, Vector2 offset);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern int ImFontAtlas_AddCustomRectRegular(ImFontAtlas* self, int width, int height);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImFont* ImFontAtlas_AddFont(ImFontAtlas* self, ImFontConfig* font_cfg);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImFont* ImFontAtlas_AddFontDefault(ImFontAtlas* self, ImFontConfig* font_cfg);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImFont* ImFontAtlas_AddFontFromFileTTF(ImFontAtlas* self, byte* filename, float size_pixels, ImFontConfig* font_cfg, ushort* glyph_ranges);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImFont* ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(ImFontAtlas* self, byte* compressed_font_data_base85, float size_pixels, ImFontConfig* font_cfg, ushort* glyph_ranges);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImFont* ImFontAtlas_AddFontFromMemoryCompressedTTF(ImFontAtlas* self, void* compressed_font_data, int compressed_font_size, float size_pixels, ImFontConfig* font_cfg, ushort* glyph_ranges);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImFont* ImFontAtlas_AddFontFromMemoryTTF(ImFontAtlas* self, void* font_data, int font_size, float size_pixels, ImFontConfig* font_cfg, ushort* glyph_ranges);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte ImFontAtlas_Build(ImFontAtlas* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFontAtlas_CalcCustomRectUV(ImFontAtlas* self, ImFontAtlasCustomRect* rect, Vector2* out_uv_min, Vector2* out_uv_max);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFontAtlas_Clear(ImFontAtlas* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFontAtlas_ClearFonts(ImFontAtlas* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFontAtlas_ClearInputData(ImFontAtlas* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFontAtlas_ClearTexData(ImFontAtlas* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFontAtlas_destroy(ImFontAtlas* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImFontAtlasCustomRect* ImFontAtlas_GetCustomRectByIndex(ImFontAtlas* self, int index);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ushort* ImFontAtlas_GetGlyphRangesChineseFull(ImFontAtlas* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ushort* ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon(ImFontAtlas* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ushort* ImFontAtlas_GetGlyphRangesCyrillic(ImFontAtlas* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ushort* ImFontAtlas_GetGlyphRangesDefault(ImFontAtlas* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ushort* ImFontAtlas_GetGlyphRangesGreek(ImFontAtlas* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ushort* ImFontAtlas_GetGlyphRangesJapanese(ImFontAtlas* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ushort* ImFontAtlas_GetGlyphRangesKorean(ImFontAtlas* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ushort* ImFontAtlas_GetGlyphRangesThai(ImFontAtlas* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ushort* ImFontAtlas_GetGlyphRangesVietnamese(ImFontAtlas* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte ImFontAtlas_GetMouseCursorTexData(ImFontAtlas* self, ImGuiMouseCursor cursor, Vector2* out_offset, Vector2* out_size, Vector2* out_uv_border, Vector2* out_uv_fill);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFontAtlas_GetTexDataAsAlpha8(ImFontAtlas* self, byte** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFontAtlas_GetTexDataAsAlpha8(ImFontAtlas* self, IntPtr* out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFontAtlas_GetTexDataAsRGBA32(ImFontAtlas* self, byte** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFontAtlas_GetTexDataAsRGBA32(ImFontAtlas* self, IntPtr* out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImFontAtlas* ImFontAtlas_ImFontAtlas();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte ImFontAtlas_IsBuilt(ImFontAtlas* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFontAtlas_SetTexID(ImFontAtlas* self, IntPtr id);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFontAtlasCustomRect_destroy(ImFontAtlasCustomRect* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImFontAtlasCustomRect* ImFontAtlasCustomRect_ImFontAtlasCustomRect();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte ImFontAtlasCustomRect_IsPacked(ImFontAtlasCustomRect* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFontConfig_destroy(ImFontConfig* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImFontConfig* ImFontConfig_ImFontConfig();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFontGlyphRangesBuilder_AddChar(ImFontGlyphRangesBuilder* self, ushort c);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFontGlyphRangesBuilder_AddRanges(ImFontGlyphRangesBuilder* self, ushort* ranges);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFontGlyphRangesBuilder_AddText(ImFontGlyphRangesBuilder* self, byte* text, byte* text_end);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFontGlyphRangesBuilder_BuildRanges(ImFontGlyphRangesBuilder* self, ImVector* out_ranges);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFontGlyphRangesBuilder_Clear(ImFontGlyphRangesBuilder* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFontGlyphRangesBuilder_destroy(ImFontGlyphRangesBuilder* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte ImFontGlyphRangesBuilder_GetBit(ImFontGlyphRangesBuilder* self, uint n);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImFontGlyphRangesBuilder* ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImFontGlyphRangesBuilder_SetBit(ImFontGlyphRangesBuilder* self, uint n);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiInputTextCallbackData_ClearSelection(ImGuiInputTextCallbackData* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiInputTextCallbackData_DeleteChars(ImGuiInputTextCallbackData* self, int pos, int bytes_count);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiInputTextCallbackData_destroy(ImGuiInputTextCallbackData* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte ImGuiInputTextCallbackData_HasSelection(ImGuiInputTextCallbackData* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiInputTextCallbackData* ImGuiInputTextCallbackData_ImGuiInputTextCallbackData();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiInputTextCallbackData_InsertChars(ImGuiInputTextCallbackData* self, int pos, byte* text, byte* text_end);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiInputTextCallbackData_SelectAll(ImGuiInputTextCallbackData* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiIO_AddFocusEvent(ImGuiIO* self, byte focused);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiIO_AddInputCharacter(ImGuiIO* self, uint c);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiIO_AddInputCharactersUTF8(ImGuiIO* self, byte* str);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiIO_AddInputCharacterUTF16(ImGuiIO* self, ushort c);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiIO_AddKeyAnalogEvent(ImGuiIO* self, ImGuiKey key, byte down, float v);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiIO_AddKeyEvent(ImGuiIO* self, ImGuiKey key, byte down);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiIO_AddMouseButtonEvent(ImGuiIO* self, int button, byte down);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiIO_AddMousePosEvent(ImGuiIO* self, float x, float y);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiIO_AddMouseViewportEvent(ImGuiIO* self, uint id);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiIO_AddMouseWheelEvent(ImGuiIO* self, float wh_x, float wh_y);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiIO_ClearInputCharacters(ImGuiIO* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiIO_ClearInputKeys(ImGuiIO* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiIO_destroy(ImGuiIO* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiIO* ImGuiIO_ImGuiIO();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiIO_SetAppAcceptingEvents(ImGuiIO* self, byte accepting_events);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiIO_SetKeyEventNativeData(ImGuiIO* self, ImGuiKey key, int native_keycode, int native_scancode, int native_legacy_index);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiListClipper_Begin(ImGuiListClipper* self, int items_count, float items_height);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiListClipper_destroy(ImGuiListClipper* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiListClipper_End(ImGuiListClipper* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiListClipper_ForceDisplayRangeByIndices(ImGuiListClipper* self, int item_min, int item_max);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiListClipper* ImGuiListClipper_ImGuiListClipper();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte ImGuiListClipper_Step(ImGuiListClipper* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiOnceUponAFrame_destroy(ImGuiOnceUponAFrame* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiOnceUponAFrame* ImGuiOnceUponAFrame_ImGuiOnceUponAFrame();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiPayload_Clear(ImGuiPayload* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiPayload_destroy(ImGuiPayload* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiPayload* ImGuiPayload_ImGuiPayload();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte ImGuiPayload_IsDataType(ImGuiPayload* self, byte* type);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte ImGuiPayload_IsDelivery(ImGuiPayload* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte ImGuiPayload_IsPreview(ImGuiPayload* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiPlatformImeData_destroy(ImGuiPlatformImeData* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiPlatformImeData* ImGuiPlatformImeData_ImGuiPlatformImeData();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiPlatformIO_destroy(ImGuiPlatformIO* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiPlatformIO* ImGuiPlatformIO_ImGuiPlatformIO();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiPlatformMonitor_destroy(ImGuiPlatformMonitor* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiPlatformMonitor* ImGuiPlatformMonitor_ImGuiPlatformMonitor();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiStorage_BuildSortByKey(ImGuiStorage* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiStorage_Clear(ImGuiStorage* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte ImGuiStorage_GetBool(ImGuiStorage* self, uint key, byte default_val);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte* ImGuiStorage_GetBoolRef(ImGuiStorage* self, uint key, byte default_val);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern float ImGuiStorage_GetFloat(ImGuiStorage* self, uint key, float default_val);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern float* ImGuiStorage_GetFloatRef(ImGuiStorage* self, uint key, float default_val);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern int ImGuiStorage_GetInt(ImGuiStorage* self, uint key, int default_val);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern int* ImGuiStorage_GetIntRef(ImGuiStorage* self, uint key, int default_val);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void* ImGuiStorage_GetVoidPtr(ImGuiStorage* self, uint key);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void** ImGuiStorage_GetVoidPtrRef(ImGuiStorage* self, uint key, void* default_val);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiStorage_SetAllInt(ImGuiStorage* self, int val);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiStorage_SetBool(ImGuiStorage* self, uint key, byte val);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiStorage_SetFloat(ImGuiStorage* self, uint key, float val);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiStorage_SetInt(ImGuiStorage* self, uint key, int val);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiStorage_SetVoidPtr(ImGuiStorage* self, uint key, void* val);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiStoragePair_destroy(ImGuiStoragePair* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePair_Int(uint _key, int _val_i);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePair_Float(uint _key, float _val_f);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePair_Ptr(uint _key, void* _val_p);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiStyle_destroy(ImGuiStyle* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiStyle* ImGuiStyle_ImGuiStyle();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiStyle_ScaleAllSizes(ImGuiStyle* self, float scale_factor);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiTableColumnSortSpecs_destroy(ImGuiTableColumnSortSpecs* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiTableColumnSortSpecs* ImGuiTableColumnSortSpecs_ImGuiTableColumnSortSpecs();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiTableSortSpecs_destroy(ImGuiTableSortSpecs* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiTableSortSpecs* ImGuiTableSortSpecs_ImGuiTableSortSpecs();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiTextBuffer_append(ImGuiTextBuffer* self, byte* str, byte* str_end);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiTextBuffer_appendf(ImGuiTextBuffer* self, byte* fmt);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte* ImGuiTextBuffer_begin(ImGuiTextBuffer* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte* ImGuiTextBuffer_c_str(ImGuiTextBuffer* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiTextBuffer_clear(ImGuiTextBuffer* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiTextBuffer_destroy(ImGuiTextBuffer* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte ImGuiTextBuffer_empty(ImGuiTextBuffer* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte* ImGuiTextBuffer_end(ImGuiTextBuffer* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiTextBuffer* ImGuiTextBuffer_ImGuiTextBuffer();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiTextBuffer_reserve(ImGuiTextBuffer* self, int capacity);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern int ImGuiTextBuffer_size(ImGuiTextBuffer* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiTextFilter_Build(ImGuiTextFilter* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiTextFilter_Clear(ImGuiTextFilter* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiTextFilter_destroy(ImGuiTextFilter* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte ImGuiTextFilter_Draw(ImGuiTextFilter* self, byte* label, float width);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiTextFilter* ImGuiTextFilter_ImGuiTextFilter(byte* default_filter);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte ImGuiTextFilter_IsActive(ImGuiTextFilter* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte ImGuiTextFilter_PassFilter(ImGuiTextFilter* self, byte* text, byte* text_end);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiTextRange_destroy(ImGuiTextRange* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern byte ImGuiTextRange_empty(ImGuiTextRange* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiTextRange* ImGuiTextRange_ImGuiTextRange_Nil();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiTextRange* ImGuiTextRange_ImGuiTextRange_Str(byte* _b, byte* _e);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiTextRange_split(ImGuiTextRange* self, byte separator, ImVector* @out);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiViewport_destroy(ImGuiViewport* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiViewport_GetCenter(Vector2* pOut, ImGuiViewport* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiViewport_GetWorkCenter(Vector2* pOut, ImGuiViewport* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiViewport* ImGuiViewport_ImGuiViewport();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImGuiWindowClass_destroy(ImGuiWindowClass* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern ImGuiWindowClass* ImGuiWindowClass_ImGuiWindowClass();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImVec2_destroy(Vector2* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern Vector2* ImVec2_ImVec2_Nil();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern Vector2* ImVec2_ImVec2_Float(float _x, float _y);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern void ImVec4_destroy(Vector4* self);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern Vector4* ImVec4_ImVec4_Nil();

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	public unsafe static extern Vector4* ImVec4_ImVec4_Float(float _x, float _y, float _z, float _w);
}
public enum ImGuiNavInput
{
	Activate,
	Cancel,
	Input,
	Menu,
	DpadLeft,
	DpadRight,
	DpadUp,
	DpadDown,
	LStickLeft,
	LStickRight,
	LStickUp,
	LStickDown,
	FocusPrev,
	FocusNext,
	TweakSlow,
	TweakFast,
	COUNT
}
public struct ImGuiOnceUponAFrame
{
	public int RefFrame;
}
public struct ImGuiOnceUponAFramePtr
{
	public unsafe ImGuiOnceUponAFrame* NativePtr { get; }

	public unsafe ref int RefFrame => ref Unsafe.AsRef<int>(&NativePtr->RefFrame);

	public unsafe ImGuiOnceUponAFramePtr(ImGuiOnceUponAFrame* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImGuiOnceUponAFramePtr(IntPtr nativePtr)
	{
		NativePtr = (ImGuiOnceUponAFrame*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImGuiOnceUponAFramePtr(ImGuiOnceUponAFrame* nativePtr)
	{
		return new ImGuiOnceUponAFramePtr(nativePtr);
	}

	public unsafe static implicit operator ImGuiOnceUponAFrame*(ImGuiOnceUponAFramePtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImGuiOnceUponAFramePtr(IntPtr nativePtr)
	{
		return new ImGuiOnceUponAFramePtr(nativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImGuiOnceUponAFrame_destroy(NativePtr);
	}
}
public struct ImGuiPayload
{
	public unsafe void* Data;

	public int DataSize;

	public uint SourceId;

	public uint SourceParentId;

	public int DataFrameCount;

	public unsafe fixed byte DataType[33];

	public byte Preview;

	public byte Delivery;
}
public struct ImGuiPayloadPtr
{
	public unsafe ImGuiPayload* NativePtr { get; }

	public unsafe IntPtr Data
	{
		get
		{
			return (IntPtr)NativePtr->Data;
		}
		set
		{
			NativePtr->Data = (void*)value;
		}
	}

	public unsafe ref int DataSize => ref Unsafe.AsRef<int>(&NativePtr->DataSize);

	public unsafe ref uint SourceId => ref Unsafe.AsRef<uint>(&NativePtr->SourceId);

	public unsafe ref uint SourceParentId => ref Unsafe.AsRef<uint>(&NativePtr->SourceParentId);

	public unsafe ref int DataFrameCount => ref Unsafe.AsRef<int>(&NativePtr->DataFrameCount);

	public unsafe RangeAccessor<byte> DataType => new RangeAccessor<byte>(NativePtr->DataType, 33);

	public unsafe ref bool Preview => ref Unsafe.AsRef<bool>(&NativePtr->Preview);

	public unsafe ref bool Delivery => ref Unsafe.AsRef<bool>(&NativePtr->Delivery);

	public unsafe ImGuiPayloadPtr(ImGuiPayload* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImGuiPayloadPtr(IntPtr nativePtr)
	{
		NativePtr = (ImGuiPayload*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImGuiPayloadPtr(ImGuiPayload* nativePtr)
	{
		return new ImGuiPayloadPtr(nativePtr);
	}

	public unsafe static implicit operator ImGuiPayload*(ImGuiPayloadPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImGuiPayloadPtr(IntPtr nativePtr)
	{
		return new ImGuiPayloadPtr(nativePtr);
	}

	public unsafe void Clear()
	{
		ImGuiNative.ImGuiPayload_Clear(NativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImGuiPayload_destroy(NativePtr);
	}

	public unsafe bool IsDataType(string type)
	{
		int num = 0;
		byte* ptr;
		if (type != null)
		{
			num = Encoding.UTF8.GetByteCount(type);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(type, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.ImGuiPayload_IsDataType(NativePtr, ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe bool IsDelivery()
	{
		return ImGuiNative.ImGuiPayload_IsDelivery(NativePtr) != 0;
	}

	public unsafe bool IsPreview()
	{
		return ImGuiNative.ImGuiPayload_IsPreview(NativePtr) != 0;
	}
}
public struct ImGuiPlatformImeData
{
	public byte WantVisible;

	public Vector2 InputPos;

	public float InputLineHeight;
}
public struct ImGuiPlatformImeDataPtr
{
	public unsafe ImGuiPlatformImeData* NativePtr { get; }

	public unsafe ref bool WantVisible => ref Unsafe.AsRef<bool>(&NativePtr->WantVisible);

	public unsafe ref Vector2 InputPos => ref Unsafe.AsRef<Vector2>(&NativePtr->InputPos);

	public unsafe ref float InputLineHeight => ref Unsafe.AsRef<float>(&NativePtr->InputLineHeight);

	public unsafe ImGuiPlatformImeDataPtr(ImGuiPlatformImeData* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImGuiPlatformImeDataPtr(IntPtr nativePtr)
	{
		NativePtr = (ImGuiPlatformImeData*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImGuiPlatformImeDataPtr(ImGuiPlatformImeData* nativePtr)
	{
		return new ImGuiPlatformImeDataPtr(nativePtr);
	}

	public unsafe static implicit operator ImGuiPlatformImeData*(ImGuiPlatformImeDataPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImGuiPlatformImeDataPtr(IntPtr nativePtr)
	{
		return new ImGuiPlatformImeDataPtr(nativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImGuiPlatformImeData_destroy(NativePtr);
	}
}
public struct ImGuiPlatformIO
{
	public IntPtr Platform_CreateWindow;

	public IntPtr Platform_DestroyWindow;

	public IntPtr Platform_ShowWindow;

	public IntPtr Platform_SetWindowPos;

	public IntPtr Platform_GetWindowPos;

	public IntPtr Platform_SetWindowSize;

	public IntPtr Platform_GetWindowSize;

	public IntPtr Platform_SetWindowFocus;

	public IntPtr Platform_GetWindowFocus;

	public IntPtr Platform_GetWindowMinimized;

	public IntPtr Platform_SetWindowTitle;

	public IntPtr Platform_SetWindowAlpha;

	public IntPtr Platform_UpdateWindow;

	public IntPtr Platform_RenderWindow;

	public IntPtr Platform_SwapBuffers;

	public IntPtr Platform_GetWindowDpiScale;

	public IntPtr Platform_OnChangedViewport;

	public IntPtr Platform_CreateVkSurface;

	public IntPtr Renderer_CreateWindow;

	public IntPtr Renderer_DestroyWindow;

	public IntPtr Renderer_SetWindowSize;

	public IntPtr Renderer_RenderWindow;

	public IntPtr Renderer_SwapBuffers;

	public ImVector Monitors;

	public ImVector Viewports;
}
public struct ImGuiPlatformIOPtr
{
	public unsafe ImGuiPlatformIO* NativePtr { get; }

	public unsafe ref IntPtr Platform_CreateWindow => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_CreateWindow);

	public unsafe ref IntPtr Platform_DestroyWindow => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_DestroyWindow);

	public unsafe ref IntPtr Platform_ShowWindow => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_ShowWindow);

	public unsafe ref IntPtr Platform_SetWindowPos => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_SetWindowPos);

	public unsafe ref IntPtr Platform_GetWindowPos => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_GetWindowPos);

	public unsafe ref IntPtr Platform_SetWindowSize => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_SetWindowSize);

	public unsafe ref IntPtr Platform_GetWindowSize => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_GetWindowSize);

	public unsafe ref IntPtr Platform_SetWindowFocus => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_SetWindowFocus);

	public unsafe ref IntPtr Platform_GetWindowFocus => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_GetWindowFocus);

	public unsafe ref IntPtr Platform_GetWindowMinimized => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_GetWindowMinimized);

	public unsafe ref IntPtr Platform_SetWindowTitle => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_SetWindowTitle);

	public unsafe ref IntPtr Platform_SetWindowAlpha => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_SetWindowAlpha);

	public unsafe ref IntPtr Platform_UpdateWindow => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_UpdateWindow);

	public unsafe ref IntPtr Platform_RenderWindow => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_RenderWindow);

	public unsafe ref IntPtr Platform_SwapBuffers => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_SwapBuffers);

	public unsafe ref IntPtr Platform_GetWindowDpiScale => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_GetWindowDpiScale);

	public unsafe ref IntPtr Platform_OnChangedViewport => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_OnChangedViewport);

	public unsafe ref IntPtr Platform_CreateVkSurface => ref Unsafe.AsRef<IntPtr>(&NativePtr->Platform_CreateVkSurface);

	public unsafe ref IntPtr Renderer_CreateWindow => ref Unsafe.AsRef<IntPtr>(&NativePtr->Renderer_CreateWindow);

	public unsafe ref IntPtr Renderer_DestroyWindow => ref Unsafe.AsRef<IntPtr>(&NativePtr->Renderer_DestroyWindow);

	public unsafe ref IntPtr Renderer_SetWindowSize => ref Unsafe.AsRef<IntPtr>(&NativePtr->Renderer_SetWindowSize);

	public unsafe ref IntPtr Renderer_RenderWindow => ref Unsafe.AsRef<IntPtr>(&NativePtr->Renderer_RenderWindow);

	public unsafe ref IntPtr Renderer_SwapBuffers => ref Unsafe.AsRef<IntPtr>(&NativePtr->Renderer_SwapBuffers);

	public unsafe ImPtrVector<ImGuiPlatformMonitorPtr> Monitors => new ImPtrVector<ImGuiPlatformMonitorPtr>(NativePtr->Monitors, Unsafe.SizeOf<ImGuiPlatformMonitor>());

	public unsafe ImVector<ImGuiViewportPtr> Viewports => new ImVector<ImGuiViewportPtr>(NativePtr->Viewports);

	public unsafe ImGuiPlatformIOPtr(ImGuiPlatformIO* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImGuiPlatformIOPtr(IntPtr nativePtr)
	{
		NativePtr = (ImGuiPlatformIO*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImGuiPlatformIOPtr(ImGuiPlatformIO* nativePtr)
	{
		return new ImGuiPlatformIOPtr(nativePtr);
	}

	public unsafe static implicit operator ImGuiPlatformIO*(ImGuiPlatformIOPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImGuiPlatformIOPtr(IntPtr nativePtr)
	{
		return new ImGuiPlatformIOPtr(nativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImGuiPlatformIO_destroy(NativePtr);
	}
}
public struct ImGuiPlatformMonitor
{
	public Vector2 MainPos;

	public Vector2 MainSize;

	public Vector2 WorkPos;

	public Vector2 WorkSize;

	public float DpiScale;
}
public struct ImGuiPlatformMonitorPtr
{
	public unsafe ImGuiPlatformMonitor* NativePtr { get; }

	public unsafe ref Vector2 MainPos => ref Unsafe.AsRef<Vector2>(&NativePtr->MainPos);

	public unsafe ref Vector2 MainSize => ref Unsafe.AsRef<Vector2>(&NativePtr->MainSize);

	public unsafe ref Vector2 WorkPos => ref Unsafe.AsRef<Vector2>(&NativePtr->WorkPos);

	public unsafe ref Vector2 WorkSize => ref Unsafe.AsRef<Vector2>(&NativePtr->WorkSize);

	public unsafe ref float DpiScale => ref Unsafe.AsRef<float>(&NativePtr->DpiScale);

	public unsafe ImGuiPlatformMonitorPtr(ImGuiPlatformMonitor* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImGuiPlatformMonitorPtr(IntPtr nativePtr)
	{
		NativePtr = (ImGuiPlatformMonitor*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImGuiPlatformMonitorPtr(ImGuiPlatformMonitor* nativePtr)
	{
		return new ImGuiPlatformMonitorPtr(nativePtr);
	}

	public unsafe static implicit operator ImGuiPlatformMonitor*(ImGuiPlatformMonitorPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImGuiPlatformMonitorPtr(IntPtr nativePtr)
	{
		return new ImGuiPlatformMonitorPtr(nativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImGuiPlatformMonitor_destroy(NativePtr);
	}
}
[Flags]
public enum ImGuiPopupFlags
{
	None = 0,
	MouseButtonLeft = 0,
	MouseButtonRight = 1,
	MouseButtonMiddle = 2,
	MouseButtonMask = 0x1F,
	MouseButtonDefault = 1,
	NoOpenOverExistingPopup = 0x20,
	NoOpenOverItems = 0x40,
	AnyPopupId = 0x80,
	AnyPopupLevel = 0x100,
	AnyPopup = 0x180
}
[Flags]
public enum ImGuiSelectableFlags
{
	None = 0,
	DontClosePopups = 1,
	SpanAllColumns = 2,
	AllowDoubleClick = 4,
	Disabled = 8,
	AllowItemOverlap = 0x10
}
public struct ImGuiSizeCallbackData
{
	public unsafe void* UserData;

	public Vector2 Pos;

	public Vector2 CurrentSize;

	public Vector2 DesiredSize;
}
public struct ImGuiSizeCallbackDataPtr
{
	public unsafe ImGuiSizeCallbackData* NativePtr { get; }

	public unsafe IntPtr UserData
	{
		get
		{
			return (IntPtr)NativePtr->UserData;
		}
		set
		{
			NativePtr->UserData = (void*)value;
		}
	}

	public unsafe ref Vector2 Pos => ref Unsafe.AsRef<Vector2>(&NativePtr->Pos);

	public unsafe ref Vector2 CurrentSize => ref Unsafe.AsRef<Vector2>(&NativePtr->CurrentSize);

	public unsafe ref Vector2 DesiredSize => ref Unsafe.AsRef<Vector2>(&NativePtr->DesiredSize);

	public unsafe ImGuiSizeCallbackDataPtr(ImGuiSizeCallbackData* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImGuiSizeCallbackDataPtr(IntPtr nativePtr)
	{
		NativePtr = (ImGuiSizeCallbackData*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImGuiSizeCallbackDataPtr(ImGuiSizeCallbackData* nativePtr)
	{
		return new ImGuiSizeCallbackDataPtr(nativePtr);
	}

	public unsafe static implicit operator ImGuiSizeCallbackData*(ImGuiSizeCallbackDataPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImGuiSizeCallbackDataPtr(IntPtr nativePtr)
	{
		return new ImGuiSizeCallbackDataPtr(nativePtr);
	}
}
[Flags]
public enum ImGuiSliderFlags
{
	None = 0,
	AlwaysClamp = 0x10,
	Logarithmic = 0x20,
	NoRoundToFormat = 0x40,
	NoInput = 0x80,
	InvalidMask = 0x7000000F
}
public enum ImGuiSortDirection
{
	None,
	Ascending,
	Descending
}
public struct ImGuiStorage
{
	public ImVector Data;
}
public struct ImGuiStoragePtr
{
	public unsafe ImGuiStorage* NativePtr { get; }

	public unsafe ImPtrVector<ImGuiStoragePairPtr> Data => new ImPtrVector<ImGuiStoragePairPtr>(NativePtr->Data, Unsafe.SizeOf<ImGuiStoragePair>());

	public unsafe ImGuiStoragePtr(ImGuiStorage* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImGuiStoragePtr(IntPtr nativePtr)
	{
		NativePtr = (ImGuiStorage*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImGuiStoragePtr(ImGuiStorage* nativePtr)
	{
		return new ImGuiStoragePtr(nativePtr);
	}

	public unsafe static implicit operator ImGuiStorage*(ImGuiStoragePtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImGuiStoragePtr(IntPtr nativePtr)
	{
		return new ImGuiStoragePtr(nativePtr);
	}

	public unsafe void BuildSortByKey()
	{
		ImGuiNative.ImGuiStorage_BuildSortByKey(NativePtr);
	}

	public unsafe void Clear()
	{
		ImGuiNative.ImGuiStorage_Clear(NativePtr);
	}

	public unsafe bool GetBool(uint key)
	{
		byte default_val = 0;
		return ImGuiNative.ImGuiStorage_GetBool(NativePtr, key, default_val) != 0;
	}

	public unsafe bool GetBool(uint key, bool default_val)
	{
		byte default_val2 = (byte)(default_val ? 1 : 0);
		return ImGuiNative.ImGuiStorage_GetBool(NativePtr, key, default_val2) != 0;
	}

	public unsafe byte* GetBoolRef(uint key)
	{
		byte default_val = 0;
		return ImGuiNative.ImGuiStorage_GetBoolRef(NativePtr, key, default_val);
	}

	public unsafe byte* GetBoolRef(uint key, bool default_val)
	{
		byte default_val2 = (byte)(default_val ? 1 : 0);
		return ImGuiNative.ImGuiStorage_GetBoolRef(NativePtr, key, default_val2);
	}

	public unsafe float GetFloat(uint key)
	{
		float default_val = 0f;
		return ImGuiNative.ImGuiStorage_GetFloat(NativePtr, key, default_val);
	}

	public unsafe float GetFloat(uint key, float default_val)
	{
		return ImGuiNative.ImGuiStorage_GetFloat(NativePtr, key, default_val);
	}

	public unsafe float* GetFloatRef(uint key)
	{
		float default_val = 0f;
		return ImGuiNative.ImGuiStorage_GetFloatRef(NativePtr, key, default_val);
	}

	public unsafe float* GetFloatRef(uint key, float default_val)
	{
		return ImGuiNative.ImGuiStorage_GetFloatRef(NativePtr, key, default_val);
	}

	public unsafe int GetInt(uint key)
	{
		int default_val = 0;
		return ImGuiNative.ImGuiStorage_GetInt(NativePtr, key, default_val);
	}

	public unsafe int GetInt(uint key, int default_val)
	{
		return ImGuiNative.ImGuiStorage_GetInt(NativePtr, key, default_val);
	}

	public unsafe int* GetIntRef(uint key)
	{
		int default_val = 0;
		return ImGuiNative.ImGuiStorage_GetIntRef(NativePtr, key, default_val);
	}

	public unsafe int* GetIntRef(uint key, int default_val)
	{
		return ImGuiNative.ImGuiStorage_GetIntRef(NativePtr, key, default_val);
	}

	public unsafe IntPtr GetVoidPtr(uint key)
	{
		return (IntPtr)ImGuiNative.ImGuiStorage_GetVoidPtr(NativePtr, key);
	}

	public unsafe void** GetVoidPtrRef(uint key)
	{
		void* default_val = null;
		return ImGuiNative.ImGuiStorage_GetVoidPtrRef(NativePtr, key, default_val);
	}

	public unsafe void** GetVoidPtrRef(uint key, IntPtr default_val)
	{
		void* default_val2 = default_val.ToPointer();
		return ImGuiNative.ImGuiStorage_GetVoidPtrRef(NativePtr, key, default_val2);
	}

	public unsafe void SetAllInt(int val)
	{
		ImGuiNative.ImGuiStorage_SetAllInt(NativePtr, val);
	}

	public unsafe void SetBool(uint key, bool val)
	{
		byte val2 = (byte)(val ? 1 : 0);
		ImGuiNative.ImGuiStorage_SetBool(NativePtr, key, val2);
	}

	public unsafe void SetFloat(uint key, float val)
	{
		ImGuiNative.ImGuiStorage_SetFloat(NativePtr, key, val);
	}

	public unsafe void SetInt(uint key, int val)
	{
		ImGuiNative.ImGuiStorage_SetInt(NativePtr, key, val);
	}

	public unsafe void SetVoidPtr(uint key, IntPtr val)
	{
		void* val2 = val.ToPointer();
		ImGuiNative.ImGuiStorage_SetVoidPtr(NativePtr, key, val2);
	}
}
public struct ImGuiStyle
{
	public float Alpha;

	public float DisabledAlpha;

	public Vector2 WindowPadding;

	public float WindowRounding;

	public float WindowBorderSize;

	public Vector2 WindowMinSize;

	public Vector2 WindowTitleAlign;

	public ImGuiDir WindowMenuButtonPosition;

	public float ChildRounding;

	public float ChildBorderSize;

	public float PopupRounding;

	public float PopupBorderSize;

	public Vector2 FramePadding;

	public float FrameRounding;

	public float FrameBorderSize;

	public Vector2 ItemSpacing;

	public Vector2 ItemInnerSpacing;

	public Vector2 CellPadding;

	public Vector2 TouchExtraPadding;

	public float IndentSpacing;

	public float ColumnsMinSpacing;

	public float ScrollbarSize;

	public float ScrollbarRounding;

	public float GrabMinSize;

	public float GrabRounding;

	public float LogSliderDeadzone;

	public float TabRounding;

	public float TabBorderSize;

	public float TabMinWidthForCloseButton;

	public ImGuiDir ColorButtonPosition;

	public Vector2 ButtonTextAlign;

	public Vector2 SelectableTextAlign;

	public Vector2 DisplayWindowPadding;

	public Vector2 DisplaySafeAreaPadding;

	public float MouseCursorScale;

	public byte AntiAliasedLines;

	public byte AntiAliasedLinesUseTex;

	public byte AntiAliasedFill;

	public float CurveTessellationTol;

	public float CircleTessellationMaxError;

	public Vector4 Colors_0;

	public Vector4 Colors_1;

	public Vector4 Colors_2;

	public Vector4 Colors_3;

	public Vector4 Colors_4;

	public Vector4 Colors_5;

	public Vector4 Colors_6;

	public Vector4 Colors_7;

	public Vector4 Colors_8;

	public Vector4 Colors_9;

	public Vector4 Colors_10;

	public Vector4 Colors_11;

	public Vector4 Colors_12;

	public Vector4 Colors_13;

	public Vector4 Colors_14;

	public Vector4 Colors_15;

	public Vector4 Colors_16;

	public Vector4 Colors_17;

	public Vector4 Colors_18;

	public Vector4 Colors_19;

	public Vector4 Colors_20;

	public Vector4 Colors_21;

	public Vector4 Colors_22;

	public Vector4 Colors_23;

	public Vector4 Colors_24;

	public Vector4 Colors_25;

	public Vector4 Colors_26;

	public Vector4 Colors_27;

	public Vector4 Colors_28;

	public Vector4 Colors_29;

	public Vector4 Colors_30;

	public Vector4 Colors_31;

	public Vector4 Colors_32;

	public Vector4 Colors_33;

	public Vector4 Colors_34;

	public Vector4 Colors_35;

	public Vector4 Colors_36;

	public Vector4 Colors_37;

	public Vector4 Colors_38;

	public Vector4 Colors_39;

	public Vector4 Colors_40;

	public Vector4 Colors_41;

	public Vector4 Colors_42;

	public Vector4 Colors_43;

	public Vector4 Colors_44;

	public Vector4 Colors_45;

	public Vector4 Colors_46;

	public Vector4 Colors_47;

	public Vector4 Colors_48;

	public Vector4 Colors_49;

	public Vector4 Colors_50;

	public Vector4 Colors_51;

	public Vector4 Colors_52;

	public Vector4 Colors_53;

	public Vector4 Colors_54;
}
public struct ImGuiStylePtr
{
	public unsafe ImGuiStyle* NativePtr { get; }

	public unsafe ref float Alpha => ref Unsafe.AsRef<float>(&NativePtr->Alpha);

	public unsafe ref float DisabledAlpha => ref Unsafe.AsRef<float>(&NativePtr->DisabledAlpha);

	public unsafe ref Vector2 WindowPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->WindowPadding);

	public unsafe ref float WindowRounding => ref Unsafe.AsRef<float>(&NativePtr->WindowRounding);

	public unsafe ref float WindowBorderSize => ref Unsafe.AsRef<float>(&NativePtr->WindowBorderSize);

	public unsafe ref Vector2 WindowMinSize => ref Unsafe.AsRef<Vector2>(&NativePtr->WindowMinSize);

	public unsafe ref Vector2 WindowTitleAlign => ref Unsafe.AsRef<Vector2>(&NativePtr->WindowTitleAlign);

	public unsafe ref ImGuiDir WindowMenuButtonPosition => ref Unsafe.AsRef<ImGuiDir>(&NativePtr->WindowMenuButtonPosition);

	public unsafe ref float ChildRounding => ref Unsafe.AsRef<float>(&NativePtr->ChildRounding);

	public unsafe ref float ChildBorderSize => ref Unsafe.AsRef<float>(&NativePtr->ChildBorderSize);

	public unsafe ref float PopupRounding => ref Unsafe.AsRef<float>(&NativePtr->PopupRounding);

	public unsafe ref float PopupBorderSize => ref Unsafe.AsRef<float>(&NativePtr->PopupBorderSize);

	public unsafe ref Vector2 FramePadding => ref Unsafe.AsRef<Vector2>(&NativePtr->FramePadding);

	public unsafe ref float FrameRounding => ref Unsafe.AsRef<float>(&NativePtr->FrameRounding);

	public unsafe ref float FrameBorderSize => ref Unsafe.AsRef<float>(&NativePtr->FrameBorderSize);

	public unsafe ref Vector2 ItemSpacing => ref Unsafe.AsRef<Vector2>(&NativePtr->ItemSpacing);

	public unsafe ref Vector2 ItemInnerSpacing => ref Unsafe.AsRef<Vector2>(&NativePtr->ItemInnerSpacing);

	public unsafe ref Vector2 CellPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->CellPadding);

	public unsafe ref Vector2 TouchExtraPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->TouchExtraPadding);

	public unsafe ref float IndentSpacing => ref Unsafe.AsRef<float>(&NativePtr->IndentSpacing);

	public unsafe ref float ColumnsMinSpacing => ref Unsafe.AsRef<float>(&NativePtr->ColumnsMinSpacing);

	public unsafe ref float ScrollbarSize => ref Unsafe.AsRef<float>(&NativePtr->ScrollbarSize);

	public unsafe ref float ScrollbarRounding => ref Unsafe.AsRef<float>(&NativePtr->ScrollbarRounding);

	public unsafe ref float GrabMinSize => ref Unsafe.AsRef<float>(&NativePtr->GrabMinSize);

	public unsafe ref float GrabRounding => ref Unsafe.AsRef<float>(&NativePtr->GrabRounding);

	public unsafe ref float LogSliderDeadzone => ref Unsafe.AsRef<float>(&NativePtr->LogSliderDeadzone);

	public unsafe ref float TabRounding => ref Unsafe.AsRef<float>(&NativePtr->TabRounding);

	public unsafe ref float TabBorderSize => ref Unsafe.AsRef<float>(&NativePtr->TabBorderSize);

	public unsafe ref float TabMinWidthForCloseButton => ref Unsafe.AsRef<float>(&NativePtr->TabMinWidthForCloseButton);

	public unsafe ref ImGuiDir ColorButtonPosition => ref Unsafe.AsRef<ImGuiDir>(&NativePtr->ColorButtonPosition);

	public unsafe ref Vector2 ButtonTextAlign => ref Unsafe.AsRef<Vector2>(&NativePtr->ButtonTextAlign);

	public unsafe ref Vector2 SelectableTextAlign => ref Unsafe.AsRef<Vector2>(&NativePtr->SelectableTextAlign);

	public unsafe ref Vector2 DisplayWindowPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->DisplayWindowPadding);

	public unsafe ref Vector2 DisplaySafeAreaPadding => ref Unsafe.AsRef<Vector2>(&NativePtr->DisplaySafeAreaPadding);

	public unsafe ref float MouseCursorScale => ref Unsafe.AsRef<float>(&NativePtr->MouseCursorScale);

	public unsafe ref bool AntiAliasedLines => ref Unsafe.AsRef<bool>(&NativePtr->AntiAliasedLines);

	public unsafe ref bool AntiAliasedLinesUseTex => ref Unsafe.AsRef<bool>(&NativePtr->AntiAliasedLinesUseTex);

	public unsafe ref bool AntiAliasedFill => ref Unsafe.AsRef<bool>(&NativePtr->AntiAliasedFill);

	public unsafe ref float CurveTessellationTol => ref Unsafe.AsRef<float>(&NativePtr->CurveTessellationTol);

	public unsafe ref float CircleTessellationMaxError => ref Unsafe.AsRef<float>(&NativePtr->CircleTessellationMaxError);

	public unsafe RangeAccessor<Vector4> Colors => new RangeAccessor<Vector4>(&NativePtr->Colors_0, 55);

	public unsafe ImGuiStylePtr(ImGuiStyle* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImGuiStylePtr(IntPtr nativePtr)
	{
		NativePtr = (ImGuiStyle*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImGuiStylePtr(ImGuiStyle* nativePtr)
	{
		return new ImGuiStylePtr(nativePtr);
	}

	public unsafe static implicit operator ImGuiStyle*(ImGuiStylePtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImGuiStylePtr(IntPtr nativePtr)
	{
		return new ImGuiStylePtr(nativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImGuiStyle_destroy(NativePtr);
	}

	public unsafe void ScaleAllSizes(float scale_factor)
	{
		ImGuiNative.ImGuiStyle_ScaleAllSizes(NativePtr, scale_factor);
	}
}
public enum ImGuiStyleVar
{
	Alpha,
	DisabledAlpha,
	WindowPadding,
	WindowRounding,
	WindowBorderSize,
	WindowMinSize,
	WindowTitleAlign,
	ChildRounding,
	ChildBorderSize,
	PopupRounding,
	PopupBorderSize,
	FramePadding,
	FrameRounding,
	FrameBorderSize,
	ItemSpacing,
	ItemInnerSpacing,
	IndentSpacing,
	CellPadding,
	ScrollbarSize,
	ScrollbarRounding,
	GrabMinSize,
	GrabRounding,
	TabRounding,
	ButtonTextAlign,
	SelectableTextAlign,
	COUNT
}
[Flags]
public enum ImGuiTabBarFlags
{
	None = 0,
	Reorderable = 1,
	AutoSelectNewTabs = 2,
	TabListPopupButton = 4,
	NoCloseWithMiddleMouseButton = 8,
	NoTabListScrollingButtons = 0x10,
	NoTooltip = 0x20,
	FittingPolicyResizeDown = 0x40,
	FittingPolicyScroll = 0x80,
	FittingPolicyMask = 0xC0,
	FittingPolicyDefault = 0x40
}
[Flags]
public enum ImGuiTabItemFlags
{
	None = 0,
	UnsavedDocument = 1,
	SetSelected = 2,
	NoCloseWithMiddleMouseButton = 4,
	NoPushId = 8,
	NoTooltip = 0x10,
	NoReorder = 0x20,
	Leading = 0x40,
	Trailing = 0x80
}
public enum ImGuiTableBgTarget
{
	None,
	RowBg0,
	RowBg1,
	CellBg
}
[Flags]
public enum ImGuiTableColumnFlags
{
	None = 0,
	Disabled = 1,
	DefaultHide = 2,
	DefaultSort = 4,
	WidthStretch = 8,
	WidthFixed = 0x10,
	NoResize = 0x20,
	NoReorder = 0x40,
	NoHide = 0x80,
	NoClip = 0x100,
	NoSort = 0x200,
	NoSortAscending = 0x400,
	NoSortDescending = 0x800,
	NoHeaderLabel = 0x1000,
	NoHeaderWidth = 0x2000,
	PreferSortAscending = 0x4000,
	PreferSortDescending = 0x8000,
	IndentEnable = 0x10000,
	IndentDisable = 0x20000,
	IsEnabled = 0x1000000,
	IsVisible = 0x2000000,
	IsSorted = 0x4000000,
	IsHovered = 0x8000000,
	WidthMask = 0x18,
	IndentMask = 0x30000,
	StatusMask = 0xF000000,
	NoDirectResize = 0x40000000
}
public struct ImGuiTableColumnSortSpecs
{
	public uint ColumnUserID;

	public short ColumnIndex;

	public short SortOrder;

	public ImGuiSortDirection SortDirection;
}
public struct ImGuiTableColumnSortSpecsPtr
{
	public unsafe ImGuiTableColumnSortSpecs* NativePtr { get; }

	public unsafe ref uint ColumnUserID => ref Unsafe.AsRef<uint>(&NativePtr->ColumnUserID);

	public unsafe ref short ColumnIndex => ref Unsafe.AsRef<short>(&NativePtr->ColumnIndex);

	public unsafe ref short SortOrder => ref Unsafe.AsRef<short>(&NativePtr->SortOrder);

	public unsafe ref ImGuiSortDirection SortDirection => ref Unsafe.AsRef<ImGuiSortDirection>(&NativePtr->SortDirection);

	public unsafe ImGuiTableColumnSortSpecsPtr(ImGuiTableColumnSortSpecs* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImGuiTableColumnSortSpecsPtr(IntPtr nativePtr)
	{
		NativePtr = (ImGuiTableColumnSortSpecs*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImGuiTableColumnSortSpecsPtr(ImGuiTableColumnSortSpecs* nativePtr)
	{
		return new ImGuiTableColumnSortSpecsPtr(nativePtr);
	}

	public unsafe static implicit operator ImGuiTableColumnSortSpecs*(ImGuiTableColumnSortSpecsPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImGuiTableColumnSortSpecsPtr(IntPtr nativePtr)
	{
		return new ImGuiTableColumnSortSpecsPtr(nativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImGuiTableColumnSortSpecs_destroy(NativePtr);
	}
}
[Flags]
public enum ImGuiTableFlags
{
	None = 0,
	Resizable = 1,
	Reorderable = 2,
	Hideable = 4,
	Sortable = 8,
	NoSavedSettings = 0x10,
	ContextMenuInBody = 0x20,
	RowBg = 0x40,
	BordersInnerH = 0x80,
	BordersOuterH = 0x100,
	BordersInnerV = 0x200,
	BordersOuterV = 0x400,
	BordersH = 0x180,
	BordersV = 0x600,
	BordersInner = 0x280,
	BordersOuter = 0x500,
	Borders = 0x780,
	NoBordersInBody = 0x800,
	NoBordersInBodyUntilResize = 0x1000,
	SizingFixedFit = 0x2000,
	SizingFixedSame = 0x4000,
	SizingStretchProp = 0x6000,
	SizingStretchSame = 0x8000,
	NoHostExtendX = 0x10000,
	NoHostExtendY = 0x20000,
	NoKeepColumnsVisible = 0x40000,
	PreciseWidths = 0x80000,
	NoClip = 0x100000,
	PadOuterX = 0x200000,
	NoPadOuterX = 0x400000,
	NoPadInnerX = 0x800000,
	ScrollX = 0x1000000,
	ScrollY = 0x2000000,
	SortMulti = 0x4000000,
	SortTristate = 0x8000000,
	SizingMask = 0xE000
}
[Flags]
public enum ImGuiTableRowFlags
{
	None = 0,
	Headers = 1
}
public struct ImGuiTableSortSpecs
{
	public unsafe ImGuiTableColumnSortSpecs* Specs;

	public int SpecsCount;

	public byte SpecsDirty;
}
public struct ImGuiTableSortSpecsPtr
{
	public unsafe ImGuiTableSortSpecs* NativePtr { get; }

	public unsafe ImGuiTableColumnSortSpecsPtr Specs => new ImGuiTableColumnSortSpecsPtr(NativePtr->Specs);

	public unsafe ref int SpecsCount => ref Unsafe.AsRef<int>(&NativePtr->SpecsCount);

	public unsafe ref bool SpecsDirty => ref Unsafe.AsRef<bool>(&NativePtr->SpecsDirty);

	public unsafe ImGuiTableSortSpecsPtr(ImGuiTableSortSpecs* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImGuiTableSortSpecsPtr(IntPtr nativePtr)
	{
		NativePtr = (ImGuiTableSortSpecs*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImGuiTableSortSpecsPtr(ImGuiTableSortSpecs* nativePtr)
	{
		return new ImGuiTableSortSpecsPtr(nativePtr);
	}

	public unsafe static implicit operator ImGuiTableSortSpecs*(ImGuiTableSortSpecsPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImGuiTableSortSpecsPtr(IntPtr nativePtr)
	{
		return new ImGuiTableSortSpecsPtr(nativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImGuiTableSortSpecs_destroy(NativePtr);
	}
}
public struct ImGuiTextBuffer
{
	public ImVector Buf;
}
public struct ImGuiTextBufferPtr
{
	public unsafe ImGuiTextBuffer* NativePtr { get; }

	public unsafe ImVector<byte> Buf => new ImVector<byte>(NativePtr->Buf);

	public unsafe ImGuiTextBufferPtr(ImGuiTextBuffer* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImGuiTextBufferPtr(IntPtr nativePtr)
	{
		NativePtr = (ImGuiTextBuffer*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImGuiTextBufferPtr(ImGuiTextBuffer* nativePtr)
	{
		return new ImGuiTextBufferPtr(nativePtr);
	}

	public unsafe static implicit operator ImGuiTextBuffer*(ImGuiTextBufferPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImGuiTextBufferPtr(IntPtr nativePtr)
	{
		return new ImGuiTextBufferPtr(nativePtr);
	}

	public unsafe void append(string str)
	{
		int num = 0;
		byte* ptr;
		if (str != null)
		{
			num = Encoding.UTF8.GetByteCount(str);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(str, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte* str_end = null;
		ImGuiNative.ImGuiTextBuffer_append(NativePtr, ptr, str_end);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe void appendf(string fmt)
	{
		int num = 0;
		byte* ptr;
		if (fmt != null)
		{
			num = Encoding.UTF8.GetByteCount(fmt);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(fmt, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		ImGuiNative.ImGuiTextBuffer_appendf(NativePtr, ptr);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
	}

	public unsafe string begin()
	{
		return Util.StringFromPtr(ImGuiNative.ImGuiTextBuffer_begin(NativePtr));
	}

	public unsafe string c_str()
	{
		return Util.StringFromPtr(ImGuiNative.ImGuiTextBuffer_c_str(NativePtr));
	}

	public unsafe void clear()
	{
		ImGuiNative.ImGuiTextBuffer_clear(NativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImGuiTextBuffer_destroy(NativePtr);
	}

	public unsafe bool empty()
	{
		return ImGuiNative.ImGuiTextBuffer_empty(NativePtr) != 0;
	}

	public unsafe string end()
	{
		return Util.StringFromPtr(ImGuiNative.ImGuiTextBuffer_end(NativePtr));
	}

	public unsafe void reserve(int capacity)
	{
		ImGuiNative.ImGuiTextBuffer_reserve(NativePtr, capacity);
	}

	public unsafe int size()
	{
		return ImGuiNative.ImGuiTextBuffer_size(NativePtr);
	}
}
public struct ImGuiTextFilter
{
	public unsafe fixed byte InputBuf[256];

	public ImVector Filters;

	public int CountGrep;
}
public struct ImGuiTextFilterPtr
{
	public unsafe ImGuiTextFilter* NativePtr { get; }

	public unsafe RangeAccessor<byte> InputBuf => new RangeAccessor<byte>(NativePtr->InputBuf, 256);

	public unsafe ImPtrVector<ImGuiTextRangePtr> Filters => new ImPtrVector<ImGuiTextRangePtr>(NativePtr->Filters, Unsafe.SizeOf<ImGuiTextRange>());

	public unsafe ref int CountGrep => ref Unsafe.AsRef<int>(&NativePtr->CountGrep);

	public unsafe ImGuiTextFilterPtr(ImGuiTextFilter* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImGuiTextFilterPtr(IntPtr nativePtr)
	{
		NativePtr = (ImGuiTextFilter*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImGuiTextFilterPtr(ImGuiTextFilter* nativePtr)
	{
		return new ImGuiTextFilterPtr(nativePtr);
	}

	public unsafe static implicit operator ImGuiTextFilter*(ImGuiTextFilterPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImGuiTextFilterPtr(IntPtr nativePtr)
	{
		return new ImGuiTextFilterPtr(nativePtr);
	}

	public unsafe void Build()
	{
		ImGuiNative.ImGuiTextFilter_Build(NativePtr);
	}

	public unsafe void Clear()
	{
		ImGuiNative.ImGuiTextFilter_Clear(NativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImGuiTextFilter_destroy(NativePtr);
	}

	public unsafe bool Draw()
	{
		int num = 0;
		num = Encoding.UTF8.GetByteCount("Filter(inc,-exc)");
		byte* ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
		int utf = Util.GetUtf8("Filter(inc,-exc)", ptr, num);
		ptr[utf] = 0;
		float width = 0f;
		byte num2 = ImGuiNative.ImGuiTextFilter_Draw(NativePtr, ptr, width);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe bool Draw(string label)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		float width = 0f;
		byte num2 = ImGuiNative.ImGuiTextFilter_Draw(NativePtr, ptr, width);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe bool Draw(string label, float width)
	{
		int num = 0;
		byte* ptr;
		if (label != null)
		{
			num = Encoding.UTF8.GetByteCount(label);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(label, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte num2 = ImGuiNative.ImGuiTextFilter_Draw(NativePtr, ptr, width);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}

	public unsafe bool IsActive()
	{
		return ImGuiNative.ImGuiTextFilter_IsActive(NativePtr) != 0;
	}

	public unsafe bool PassFilter(string text)
	{
		int num = 0;
		byte* ptr;
		if (text != null)
		{
			num = Encoding.UTF8.GetByteCount(text);
			ptr = ((num <= 2048) ? stackalloc byte[(int)(uint)(num + 1)] : Util.Allocate(num + 1));
			int utf = Util.GetUtf8(text, ptr, num);
			ptr[utf] = 0;
		}
		else
		{
			ptr = null;
		}
		byte* text_end = null;
		byte num2 = ImGuiNative.ImGuiTextFilter_PassFilter(NativePtr, ptr, text_end);
		if (num > 2048)
		{
			Util.Free(ptr);
		}
		return num2 != 0;
	}
}
public struct ImGuiTextRange
{
	public unsafe byte* b;

	public unsafe byte* e;
}
public struct ImGuiTextRangePtr
{
	public unsafe ImGuiTextRange* NativePtr { get; }

	public unsafe IntPtr b
	{
		get
		{
			return (IntPtr)NativePtr->b;
		}
		set
		{
			NativePtr->b = (byte*)(void*)value;
		}
	}

	public unsafe IntPtr e
	{
		get
		{
			return (IntPtr)NativePtr->e;
		}
		set
		{
			NativePtr->e = (byte*)(void*)value;
		}
	}

	public unsafe ImGuiTextRangePtr(ImGuiTextRange* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImGuiTextRangePtr(IntPtr nativePtr)
	{
		NativePtr = (ImGuiTextRange*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImGuiTextRangePtr(ImGuiTextRange* nativePtr)
	{
		return new ImGuiTextRangePtr(nativePtr);
	}

	public unsafe static implicit operator ImGuiTextRange*(ImGuiTextRangePtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImGuiTextRangePtr(IntPtr nativePtr)
	{
		return new ImGuiTextRangePtr(nativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImGuiTextRange_destroy(NativePtr);
	}

	public unsafe bool empty()
	{
		return ImGuiNative.ImGuiTextRange_empty(NativePtr) != 0;
	}

	public unsafe void split(byte separator, out ImVector @out)
	{
		fixed (ImVector* out2 = &@out)
		{
			ImGuiNative.ImGuiTextRange_split(NativePtr, separator, out2);
		}
	}
}
[Flags]
public enum ImGuiTreeNodeFlags
{
	None = 0,
	Selected = 1,
	Framed = 2,
	AllowItemOverlap = 4,
	NoTreePushOnOpen = 8,
	NoAutoOpenOnLog = 0x10,
	DefaultOpen = 0x20,
	OpenOnDoubleClick = 0x40,
	OpenOnArrow = 0x80,
	Leaf = 0x100,
	Bullet = 0x200,
	FramePadding = 0x400,
	SpanAvailWidth = 0x800,
	SpanFullWidth = 0x1000,
	NavLeftJumpsBackHere = 0x2000,
	CollapsingHeader = 0x1A
}
public struct ImGuiViewport
{
	public uint ID;

	public ImGuiViewportFlags Flags;

	public Vector2 Pos;

	public Vector2 Size;

	public Vector2 WorkPos;

	public Vector2 WorkSize;

	public float DpiScale;

	public uint ParentViewportId;

	public unsafe ImDrawData* DrawData;

	public unsafe void* RendererUserData;

	public unsafe void* PlatformUserData;

	public unsafe void* PlatformHandle;

	public unsafe void* PlatformHandleRaw;

	public byte PlatformWindowCreated;

	public byte PlatformRequestMove;

	public byte PlatformRequestResize;

	public byte PlatformRequestClose;
}
public struct ImGuiViewportPtr
{
	public unsafe ImGuiViewport* NativePtr { get; }

	public unsafe ref uint ID => ref Unsafe.AsRef<uint>(&NativePtr->ID);

	public unsafe ref ImGuiViewportFlags Flags => ref Unsafe.AsRef<ImGuiViewportFlags>(&NativePtr->Flags);

	public unsafe ref Vector2 Pos => ref Unsafe.AsRef<Vector2>(&NativePtr->Pos);

	public unsafe ref Vector2 Size => ref Unsafe.AsRef<Vector2>(&NativePtr->Size);

	public unsafe ref Vector2 WorkPos => ref Unsafe.AsRef<Vector2>(&NativePtr->WorkPos);

	public unsafe ref Vector2 WorkSize => ref Unsafe.AsRef<Vector2>(&NativePtr->WorkSize);

	public unsafe ref float DpiScale => ref Unsafe.AsRef<float>(&NativePtr->DpiScale);

	public unsafe ref uint ParentViewportId => ref Unsafe.AsRef<uint>(&NativePtr->ParentViewportId);

	public unsafe ImDrawDataPtr DrawData => new ImDrawDataPtr(NativePtr->DrawData);

	public unsafe IntPtr RendererUserData
	{
		get
		{
			return (IntPtr)NativePtr->RendererUserData;
		}
		set
		{
			NativePtr->RendererUserData = (void*)value;
		}
	}

	public unsafe IntPtr PlatformUserData
	{
		get
		{
			return (IntPtr)NativePtr->PlatformUserData;
		}
		set
		{
			NativePtr->PlatformUserData = (void*)value;
		}
	}

	public unsafe IntPtr PlatformHandle
	{
		get
		{
			return (IntPtr)NativePtr->PlatformHandle;
		}
		set
		{
			NativePtr->PlatformHandle = (void*)value;
		}
	}

	public unsafe IntPtr PlatformHandleRaw
	{
		get
		{
			return (IntPtr)NativePtr->PlatformHandleRaw;
		}
		set
		{
			NativePtr->PlatformHandleRaw = (void*)value;
		}
	}

	public unsafe ref bool PlatformWindowCreated => ref Unsafe.AsRef<bool>(&NativePtr->PlatformWindowCreated);

	public unsafe ref bool PlatformRequestMove => ref Unsafe.AsRef<bool>(&NativePtr->PlatformRequestMove);

	public unsafe ref bool PlatformRequestResize => ref Unsafe.AsRef<bool>(&NativePtr->PlatformRequestResize);

	public unsafe ref bool PlatformRequestClose => ref Unsafe.AsRef<bool>(&NativePtr->PlatformRequestClose);

	public unsafe ImGuiViewportPtr(ImGuiViewport* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImGuiViewportPtr(IntPtr nativePtr)
	{
		NativePtr = (ImGuiViewport*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImGuiViewportPtr(ImGuiViewport* nativePtr)
	{
		return new ImGuiViewportPtr(nativePtr);
	}

	public unsafe static implicit operator ImGuiViewport*(ImGuiViewportPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImGuiViewportPtr(IntPtr nativePtr)
	{
		return new ImGuiViewportPtr(nativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImGuiViewport_destroy(NativePtr);
	}

	public unsafe Vector2 GetCenter()
	{
		Vector2 result = default(Vector2);
		ImGuiNative.ImGuiViewport_GetCenter(&result, NativePtr);
		return result;
	}

	public unsafe Vector2 GetWorkCenter()
	{
		Vector2 result = default(Vector2);
		ImGuiNative.ImGuiViewport_GetWorkCenter(&result, NativePtr);
		return result;
	}
}
[Flags]
public enum ImGuiViewportFlags
{
	None = 0,
	IsPlatformWindow = 1,
	IsPlatformMonitor = 2,
	OwnedByApp = 4,
	NoDecoration = 8,
	NoTaskBarIcon = 0x10,
	NoFocusOnAppearing = 0x20,
	NoFocusOnClick = 0x40,
	NoInputs = 0x80,
	NoRendererClear = 0x100,
	TopMost = 0x200,
	Minimized = 0x400,
	NoAutoMerge = 0x800,
	CanHostOtherWindows = 0x1000
}
public struct ImGuiWindowClass
{
	public uint ClassId;

	public uint ParentViewportId;

	public ImGuiViewportFlags ViewportFlagsOverrideSet;

	public ImGuiViewportFlags ViewportFlagsOverrideClear;

	public ImGuiTabItemFlags TabItemFlagsOverrideSet;

	public ImGuiDockNodeFlags DockNodeFlagsOverrideSet;

	public byte DockingAlwaysTabBar;

	public byte DockingAllowUnclassed;
}
public struct ImGuiWindowClassPtr
{
	public unsafe ImGuiWindowClass* NativePtr { get; }

	public unsafe ref uint ClassId => ref Unsafe.AsRef<uint>(&NativePtr->ClassId);

	public unsafe ref uint ParentViewportId => ref Unsafe.AsRef<uint>(&NativePtr->ParentViewportId);

	public unsafe ref ImGuiViewportFlags ViewportFlagsOverrideSet => ref Unsafe.AsRef<ImGuiViewportFlags>(&NativePtr->ViewportFlagsOverrideSet);

	public unsafe ref ImGuiViewportFlags ViewportFlagsOverrideClear => ref Unsafe.AsRef<ImGuiViewportFlags>(&NativePtr->ViewportFlagsOverrideClear);

	public unsafe ref ImGuiTabItemFlags TabItemFlagsOverrideSet => ref Unsafe.AsRef<ImGuiTabItemFlags>(&NativePtr->TabItemFlagsOverrideSet);

	public unsafe ref ImGuiDockNodeFlags DockNodeFlagsOverrideSet => ref Unsafe.AsRef<ImGuiDockNodeFlags>(&NativePtr->DockNodeFlagsOverrideSet);

	public unsafe ref bool DockingAlwaysTabBar => ref Unsafe.AsRef<bool>(&NativePtr->DockingAlwaysTabBar);

	public unsafe ref bool DockingAllowUnclassed => ref Unsafe.AsRef<bool>(&NativePtr->DockingAllowUnclassed);

	public unsafe ImGuiWindowClassPtr(ImGuiWindowClass* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImGuiWindowClassPtr(IntPtr nativePtr)
	{
		NativePtr = (ImGuiWindowClass*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImGuiWindowClassPtr(ImGuiWindowClass* nativePtr)
	{
		return new ImGuiWindowClassPtr(nativePtr);
	}

	public unsafe static implicit operator ImGuiWindowClass*(ImGuiWindowClassPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImGuiWindowClassPtr(IntPtr nativePtr)
	{
		return new ImGuiWindowClassPtr(nativePtr);
	}

	public unsafe void Destroy()
	{
		ImGuiNative.ImGuiWindowClass_destroy(NativePtr);
	}
}
[Flags]
public enum ImGuiWindowFlags
{
	None = 0,
	NoTitleBar = 1,
	NoResize = 2,
	NoMove = 4,
	NoScrollbar = 8,
	NoScrollWithMouse = 0x10,
	NoCollapse = 0x20,
	AlwaysAutoResize = 0x40,
	NoBackground = 0x80,
	NoSavedSettings = 0x100,
	NoMouseInputs = 0x200,
	MenuBar = 0x400,
	HorizontalScrollbar = 0x800,
	NoFocusOnAppearing = 0x1000,
	NoBringToFrontOnFocus = 0x2000,
	AlwaysVerticalScrollbar = 0x4000,
	AlwaysHorizontalScrollbar = 0x8000,
	AlwaysUseWindowPadding = 0x10000,
	NoNavInputs = 0x40000,
	NoNavFocus = 0x80000,
	UnsavedDocument = 0x100000,
	NoDocking = 0x200000,
	NoNav = 0xC0000,
	NoDecoration = 0x2B,
	NoInputs = 0xC0200,
	NavFlattened = 0x800000,
	ChildWindow = 0x1000000,
	Tooltip = 0x2000000,
	Popup = 0x4000000,
	Modal = 0x8000000,
	ChildMenu = 0x10000000,
	DockNodeHost = 0x20000000
}
public struct StbTexteditRow
{
	public float x0;

	public float x1;

	public float baseline_y_delta;

	public float ymin;

	public float ymax;

	public int num_chars;
}
public struct StbTexteditRowPtr
{
	public unsafe StbTexteditRow* NativePtr { get; }

	public unsafe ref float x0 => ref Unsafe.AsRef<float>(&NativePtr->x0);

	public unsafe ref float x1 => ref Unsafe.AsRef<float>(&NativePtr->x1);

	public unsafe ref float baseline_y_delta => ref Unsafe.AsRef<float>(&NativePtr->baseline_y_delta);

	public unsafe ref float ymin => ref Unsafe.AsRef<float>(&NativePtr->ymin);

	public unsafe ref float ymax => ref Unsafe.AsRef<float>(&NativePtr->ymax);

	public unsafe ref int num_chars => ref Unsafe.AsRef<int>(&NativePtr->num_chars);

	public unsafe StbTexteditRowPtr(StbTexteditRow* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe StbTexteditRowPtr(IntPtr nativePtr)
	{
		NativePtr = (StbTexteditRow*)(void*)nativePtr;
	}

	public unsafe static implicit operator StbTexteditRowPtr(StbTexteditRow* nativePtr)
	{
		return new StbTexteditRowPtr(nativePtr);
	}

	public unsafe static implicit operator StbTexteditRow*(StbTexteditRowPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator StbTexteditRowPtr(IntPtr nativePtr)
	{
		return new StbTexteditRowPtr(nativePtr);
	}
}
public struct StbUndoRecord
{
	public int where;

	public int insert_length;

	public int delete_length;

	public int char_storage;
}
public struct StbUndoRecordPtr
{
	public unsafe StbUndoRecord* NativePtr { get; }

	public unsafe ref int where => ref Unsafe.AsRef<int>(&NativePtr->where);

	public unsafe ref int insert_length => ref Unsafe.AsRef<int>(&NativePtr->insert_length);

	public unsafe ref int delete_length => ref Unsafe.AsRef<int>(&NativePtr->delete_length);

	public unsafe ref int char_storage => ref Unsafe.AsRef<int>(&NativePtr->char_storage);

	public unsafe StbUndoRecordPtr(StbUndoRecord* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe StbUndoRecordPtr(IntPtr nativePtr)
	{
		NativePtr = (StbUndoRecord*)(void*)nativePtr;
	}

	public unsafe static implicit operator StbUndoRecordPtr(StbUndoRecord* nativePtr)
	{
		return new StbUndoRecordPtr(nativePtr);
	}

	public unsafe static implicit operator StbUndoRecord*(StbUndoRecordPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator StbUndoRecordPtr(IntPtr nativePtr)
	{
		return new StbUndoRecordPtr(nativePtr);
	}
}
public struct StbUndoState
{
	public StbUndoRecord undo_rec_0;

	public StbUndoRecord undo_rec_1;

	public StbUndoRecord undo_rec_2;

	public StbUndoRecord undo_rec_3;

	public StbUndoRecord undo_rec_4;

	public StbUndoRecord undo_rec_5;

	public StbUndoRecord undo_rec_6;

	public StbUndoRecord undo_rec_7;

	public StbUndoRecord undo_rec_8;

	public StbUndoRecord undo_rec_9;

	public StbUndoRecord undo_rec_10;

	public StbUndoRecord undo_rec_11;

	public StbUndoRecord undo_rec_12;

	public StbUndoRecord undo_rec_13;

	public StbUndoRecord undo_rec_14;

	public StbUndoRecord undo_rec_15;

	public StbUndoRecord undo_rec_16;

	public StbUndoRecord undo_rec_17;

	public StbUndoRecord undo_rec_18;

	public StbUndoRecord undo_rec_19;

	public StbUndoRecord undo_rec_20;

	public StbUndoRecord undo_rec_21;

	public StbUndoRecord undo_rec_22;

	public StbUndoRecord undo_rec_23;

	public StbUndoRecord undo_rec_24;

	public StbUndoRecord undo_rec_25;

	public StbUndoRecord undo_rec_26;

	public StbUndoRecord undo_rec_27;

	public StbUndoRecord undo_rec_28;

	public StbUndoRecord undo_rec_29;

	public StbUndoRecord undo_rec_30;

	public StbUndoRecord undo_rec_31;

	public StbUndoRecord undo_rec_32;

	public StbUndoRecord undo_rec_33;

	public StbUndoRecord undo_rec_34;

	public StbUndoRecord undo_rec_35;

	public StbUndoRecord undo_rec_36;

	public StbUndoRecord undo_rec_37;

	public StbUndoRecord undo_rec_38;

	public StbUndoRecord undo_rec_39;

	public StbUndoRecord undo_rec_40;

	public StbUndoRecord undo_rec_41;

	public StbUndoRecord undo_rec_42;

	public StbUndoRecord undo_rec_43;

	public StbUndoRecord undo_rec_44;

	public StbUndoRecord undo_rec_45;

	public StbUndoRecord undo_rec_46;

	public StbUndoRecord undo_rec_47;

	public StbUndoRecord undo_rec_48;

	public StbUndoRecord undo_rec_49;

	public StbUndoRecord undo_rec_50;

	public StbUndoRecord undo_rec_51;

	public StbUndoRecord undo_rec_52;

	public StbUndoRecord undo_rec_53;

	public StbUndoRecord undo_rec_54;

	public StbUndoRecord undo_rec_55;

	public StbUndoRecord undo_rec_56;

	public StbUndoRecord undo_rec_57;

	public StbUndoRecord undo_rec_58;

	public StbUndoRecord undo_rec_59;

	public StbUndoRecord undo_rec_60;

	public StbUndoRecord undo_rec_61;

	public StbUndoRecord undo_rec_62;

	public StbUndoRecord undo_rec_63;

	public StbUndoRecord undo_rec_64;

	public StbUndoRecord undo_rec_65;

	public StbUndoRecord undo_rec_66;

	public StbUndoRecord undo_rec_67;

	public StbUndoRecord undo_rec_68;

	public StbUndoRecord undo_rec_69;

	public StbUndoRecord undo_rec_70;

	public StbUndoRecord undo_rec_71;

	public StbUndoRecord undo_rec_72;

	public StbUndoRecord undo_rec_73;

	public StbUndoRecord undo_rec_74;

	public StbUndoRecord undo_rec_75;

	public StbUndoRecord undo_rec_76;

	public StbUndoRecord undo_rec_77;

	public StbUndoRecord undo_rec_78;

	public StbUndoRecord undo_rec_79;

	public StbUndoRecord undo_rec_80;

	public StbUndoRecord undo_rec_81;

	public StbUndoRecord undo_rec_82;

	public StbUndoRecord undo_rec_83;

	public StbUndoRecord undo_rec_84;

	public StbUndoRecord undo_rec_85;

	public StbUndoRecord undo_rec_86;

	public StbUndoRecord undo_rec_87;

	public StbUndoRecord undo_rec_88;

	public StbUndoRecord undo_rec_89;

	public StbUndoRecord undo_rec_90;

	public StbUndoRecord undo_rec_91;

	public StbUndoRecord undo_rec_92;

	public StbUndoRecord undo_rec_93;

	public StbUndoRecord undo_rec_94;

	public StbUndoRecord undo_rec_95;

	public StbUndoRecord undo_rec_96;

	public StbUndoRecord undo_rec_97;

	public StbUndoRecord undo_rec_98;

	public unsafe fixed ushort undo_char[999];

	public short undo_point;

	public short redo_point;

	public int undo_char_point;

	public int redo_char_point;
}
public struct StbUndoStatePtr
{
	public unsafe StbUndoState* NativePtr { get; }

	public unsafe RangeAccessor<StbUndoRecord> undo_rec => new RangeAccessor<StbUndoRecord>(&NativePtr->undo_rec_0, 99);

	public unsafe RangeAccessor<ushort> undo_char => new RangeAccessor<ushort>(NativePtr->undo_char, 999);

	public unsafe ref short undo_point => ref Unsafe.AsRef<short>(&NativePtr->undo_point);

	public unsafe ref short redo_point => ref Unsafe.AsRef<short>(&NativePtr->redo_point);

	public unsafe ref int undo_char_point => ref Unsafe.AsRef<int>(&NativePtr->undo_char_point);

	public unsafe ref int redo_char_point => ref Unsafe.AsRef<int>(&NativePtr->redo_char_point);

	public unsafe StbUndoStatePtr(StbUndoState* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe StbUndoStatePtr(IntPtr nativePtr)
	{
		NativePtr = (StbUndoState*)(void*)nativePtr;
	}

	public unsafe static implicit operator StbUndoStatePtr(StbUndoState* nativePtr)
	{
		return new StbUndoStatePtr(nativePtr);
	}

	public unsafe static implicit operator StbUndoState*(StbUndoStatePtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator StbUndoStatePtr(IntPtr nativePtr)
	{
		return new StbUndoStatePtr(nativePtr);
	}
}
public struct STB_TexteditState
{
	public int cursor;

	public int select_start;

	public int select_end;

	public byte insert_mode;

	public int row_count_per_page;

	public byte cursor_at_end_of_line;

	public byte initialized;

	public byte has_preferred_x;

	public byte single_line;

	public byte padding1;

	public byte padding2;

	public byte padding3;

	public float preferred_x;

	public StbUndoState undostate;
}
public struct STB_TexteditStatePtr
{
	public unsafe STB_TexteditState* NativePtr { get; }

	public unsafe ref int cursor => ref Unsafe.AsRef<int>(&NativePtr->cursor);

	public unsafe ref int select_start => ref Unsafe.AsRef<int>(&NativePtr->select_start);

	public unsafe ref int select_end => ref Unsafe.AsRef<int>(&NativePtr->select_end);

	public unsafe ref byte insert_mode => ref Unsafe.AsRef<byte>(&NativePtr->insert_mode);

	public unsafe ref int row_count_per_page => ref Unsafe.AsRef<int>(&NativePtr->row_count_per_page);

	public unsafe ref byte cursor_at_end_of_line => ref Unsafe.AsRef<byte>(&NativePtr->cursor_at_end_of_line);

	public unsafe ref byte initialized => ref Unsafe.AsRef<byte>(&NativePtr->initialized);

	public unsafe ref byte has_preferred_x => ref Unsafe.AsRef<byte>(&NativePtr->has_preferred_x);

	public unsafe ref byte single_line => ref Unsafe.AsRef<byte>(&NativePtr->single_line);

	public unsafe ref byte padding1 => ref Unsafe.AsRef<byte>(&NativePtr->padding1);

	public unsafe ref byte padding2 => ref Unsafe.AsRef<byte>(&NativePtr->padding2);

	public unsafe ref byte padding3 => ref Unsafe.AsRef<byte>(&NativePtr->padding3);

	public unsafe ref float preferred_x => ref Unsafe.AsRef<float>(&NativePtr->preferred_x);

	public unsafe ref StbUndoState undostate => ref Unsafe.AsRef<StbUndoState>(&NativePtr->undostate);

	public unsafe STB_TexteditStatePtr(STB_TexteditState* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe STB_TexteditStatePtr(IntPtr nativePtr)
	{
		NativePtr = (STB_TexteditState*)(void*)nativePtr;
	}

	public unsafe static implicit operator STB_TexteditStatePtr(STB_TexteditState* nativePtr)
	{
		return new STB_TexteditStatePtr(nativePtr);
	}

	public unsafe static implicit operator STB_TexteditState*(STB_TexteditStatePtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator STB_TexteditStatePtr(IntPtr nativePtr)
	{
		return new STB_TexteditStatePtr(nativePtr);
	}
}
public unsafe delegate void ImGuiSizeCallback(ImGuiSizeCallbackData* data);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public unsafe delegate int ImGuiInputTextCallback(ImGuiInputTextCallbackData* data);
public struct ImVector
{
	public readonly int Size;

	public readonly int Capacity;

	public readonly IntPtr Data;

	public unsafe ref T Ref<T>(int index)
	{
		return ref Unsafe.AsRef<T>((byte*)(void*)Data + index * Unsafe.SizeOf<T>());
	}

	public unsafe IntPtr Address<T>(int index)
	{
		return (IntPtr)((byte*)(void*)Data + index * Unsafe.SizeOf<T>());
	}
}
public struct ImVector<T>
{
	public readonly int Size;

	public readonly int Capacity;

	public readonly IntPtr Data;

	public unsafe ref T this[int index] => ref Unsafe.AsRef<T>((byte*)(void*)Data + index * Unsafe.SizeOf<T>());

	public ImVector(ImVector vector)
	{
		Size = vector.Size;
		Capacity = vector.Capacity;
		Data = vector.Data;
	}

	public ImVector(int size, int capacity, IntPtr data)
	{
		Size = size;
		Capacity = capacity;
		Data = data;
	}
}
public struct ImPtrVector<T>
{
	public readonly int Size;

	public readonly int Capacity;

	public readonly IntPtr Data;

	private readonly int _stride;

	public unsafe T this[int index]
	{
		get
		{
			byte* ptr = (byte*)(void*)Data + index * _stride;
			return Unsafe.Read<T>(&ptr);
		}
	}

	public ImPtrVector(ImVector vector, int stride)
		: this(vector.Size, vector.Capacity, vector.Data, stride)
	{
	}

	public ImPtrVector(int size, int capacity, IntPtr data, int stride)
	{
		Size = size;
		Capacity = capacity;
		Data = data;
		_stride = stride;
	}
}
public struct NullTerminatedString
{
	public unsafe readonly byte* Data;

	public unsafe NullTerminatedString(byte* data)
	{
		Data = data;
	}

	public unsafe override string ToString()
	{
		int num = 0;
		for (byte* ptr = Data; *ptr != 0; ptr++)
		{
			num++;
		}
		return Encoding.ASCII.GetString(Data, num);
	}

	public static implicit operator string(NullTerminatedString nts)
	{
		return nts.ToString();
	}
}
public struct ImGuiStoragePair
{
	public uint Key;

	public UnionValue Value;
}
public struct ImGuiStoragePairPtr
{
	public unsafe ImGuiStoragePair* NativePtr { get; }

	public unsafe ImGuiStoragePairPtr(ImGuiStoragePair* nativePtr)
	{
		NativePtr = nativePtr;
	}

	public unsafe ImGuiStoragePairPtr(IntPtr nativePtr)
	{
		NativePtr = (ImGuiStoragePair*)(void*)nativePtr;
	}

	public unsafe static implicit operator ImGuiStoragePairPtr(ImGuiStoragePair* nativePtr)
	{
		return new ImGuiStoragePairPtr(nativePtr);
	}

	public unsafe static implicit operator ImGuiStoragePair*(ImGuiStoragePairPtr wrappedPtr)
	{
		return wrappedPtr.NativePtr;
	}

	public static implicit operator ImGuiStoragePairPtr(IntPtr nativePtr)
	{
		return new ImGuiStoragePairPtr(nativePtr);
	}
}
[StructLayout(LayoutKind.Explicit)]
public struct UnionValue
{
	[FieldOffset(0)]
	public int ValueI32;

	[FieldOffset(0)]
	public float ValueF32;

	[FieldOffset(0)]
	public IntPtr ValuePtr;
}
public struct RangeAccessor<T> where T : struct
{
	private static readonly int s_sizeOfT = Unsafe.SizeOf<T>();

	public unsafe readonly void* Data;

	public readonly int Count;

	public unsafe ref T this[int index]
	{
		get
		{
			if (index < 0 || index >= Count)
			{
				throw new IndexOutOfRangeException();
			}
			return ref Unsafe.AsRef<T>((byte*)Data + s_sizeOfT * index);
		}
	}

	public unsafe RangeAccessor(IntPtr data, int count)
		: this(data.ToPointer(), count)
	{
	}

	public unsafe RangeAccessor(void* data, int count)
	{
		Data = data;
		Count = count;
	}
}
public struct RangePtrAccessor<T> where T : struct
{
	public unsafe readonly void* Data;

	public readonly int Count;

	public unsafe T this[int index]
	{
		get
		{
			if (index < 0 || index >= Count)
			{
				throw new IndexOutOfRangeException();
			}
			return Unsafe.Read<T>((byte*)Data + sizeof(void*) * index);
		}
	}

	public unsafe RangePtrAccessor(IntPtr data, int count)
		: this(data.ToPointer(), count)
	{
	}

	public unsafe RangePtrAccessor(void* data, int count)
	{
		Data = data;
		Count = count;
	}
}
public static class RangeAccessorExtensions
{
	public unsafe static string GetStringASCII(this RangeAccessor<byte> stringAccessor)
	{
		return Encoding.ASCII.GetString((byte*)stringAccessor.Data, stringAccessor.Count);
	}
}
internal static class Util
{
	internal const int StackAllocationSizeLimit = 2048;

	public unsafe static string StringFromPtr(byte* ptr)
	{
		int i;
		for (i = 0; ptr[i] != 0; i++)
		{
		}
		return Encoding.UTF8.GetString(ptr, i);
	}

	internal unsafe static bool AreStringsEqual(byte* a, int aLength, byte* b)
	{
		for (int i = 0; i < aLength; i++)
		{
			if (a[i] != b[i])
			{
				return false;
			}
		}
		if (b[aLength] != 0)
		{
			return false;
		}
		return true;
	}

	internal unsafe static byte* Allocate(int byteCount)
	{
		return (byte*)(void*)Marshal.AllocHGlobal(byteCount);
	}

	internal unsafe static void Free(byte* ptr)
	{
		Marshal.FreeHGlobal((IntPtr)ptr);
	}

	internal unsafe static int CalcSizeInUtf8(string s, int start, int length)
	{
		if (start < 0 || length < 0 || start + length > s.Length)
		{
			throw new ArgumentOutOfRangeException();
		}
		fixed (char* ptr = s)
		{
			return Encoding.UTF8.GetByteCount(ptr + start, length);
		}
	}

	internal unsafe static int GetUtf8(string s, byte* utf8Bytes, int utf8ByteCount)
	{
		fixed (char* chars = s)
		{
			return Encoding.UTF8.GetBytes(chars, s.Length, utf8Bytes, utf8ByteCount);
		}
	}

	internal unsafe static int GetUtf8(string s, int start, int length, byte* utf8Bytes, int utf8ByteCount)
	{
		if (start < 0 || length < 0 || start + length > s.Length)
		{
			throw new ArgumentOutOfRangeException();
		}
		fixed (char* ptr = s)
		{
			return Encoding.UTF8.GetBytes(ptr + start, length, utf8Bytes, utf8ByteCount);
		}
	}
}